@growupsell/react-ecommerce-core 0.0.2

package/dist/provider.cjs

@@ -0,0 +1,2034 @@
+'use strict';
+
+var react = require('react');
+var api = require('@growupsell/api');
+var jsxRuntime = require('react/jsx-runtime');
+var api$1 = require('@growupsell/api/api');
+require('lodash');
+var reactToastify = require('react-toastify');
+var fa = require('react-icons/fa');
+
+// src/provider/AuthProvider.tsx
+var StorageContext = react.createContext({
+  setItem: (key, data, type) => null,
+  getItem: (key) => null,
+  clearAll: () => null,
+  removeItem: (key) => null
+});
+var StorageProvider = (props) => {
+  const [loading, setLoading] = react.useState(false);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    StorageContext.Provider,
+    {
+      value: {
+        setItem: props.storage.setItem,
+        getItem: props.storage.getItem,
+        clearAll: props.storage.clearAll,
+        removeItem: props.storage.removeItem
+      },
+      children: loading ? null : props.children
+    }
+  );
+};
+var useStorage = () => react.useContext(StorageContext);
+var AuthContext = react.createContext({
+  signIn: () => null,
+  signOut: () => null,
+  user: null,
+  setUser: (o) => null,
+  customerSession: null,
+  loadingToken: null,
+  loadingUser: null,
+  token: null
+});
+var AuthProvider = (props) => {
+  const [user, setUser] = react.useState(null);
+  const [loading, setLoading] = react.useState(true);
+  const [customerSession, setCustomerSession] = react.useState();
+  const [loadingUser, setLoadingUser] = react.useState(true);
+  const [loadingToken, setLoadingToken] = react.useState(false);
+  const storage = useStorage();
+  const [token, setToken] = react.useState();
+  const signIn = (data, rememberMe) => {
+    if (data.is_active) {
+      api.WAApi.defaults.headers.common["x-customer-token"] = `${data.token}`;
+    }
+    const type = rememberMe ? "local" : "session";
+    storage.setItem("user", JSON.stringify(data), type);
+    setUser(data);
+  };
+  const signOut = () => {
+    setUser(null);
+    storage.clearAll();
+    delete api.WAApi.defaults.headers.common["x-customer-token"];
+  };
+  let sessionCreationInProgress = false;
+  const initializedCustomerSession = async () => {
+    setLoading(true);
+    if (sessionCreationInProgress) {
+      return;
+    }
+    sessionCreationInProgress = true;
+    let savedSession = storage.getItem("session", "session") ? JSON.parse(storage.getItem("session", "session")) : null;
+    if (savedSession) {
+      setCustomerSession(savedSession);
+      api.WAApi.defaults.headers.common["x-session-token"] = savedSession?.session_token;
+    } else {
+      try {
+        let body = {
+          customer: user?.id
+        };
+        const response = await api$1.createCustomerSession(body);
+        setCustomerSession(response);
+        api.WAApi.defaults.headers.common["x-session-token"] = response?.session_token;
+        storage.setItem("session", JSON.stringify(response), "session");
+      } catch (error) {
+        console.log("Error--->", error);
+      }
+    }
+    setLoading(false);
+    sessionCreationInProgress = false;
+  };
+  react.useEffect(() => {
+    !loadingUser && initializedCustomerSession();
+  }, [loadingUser]);
+  react.useEffect(() => {
+    setLoadingUser(true);
+    let local_user = storage.getItem("user", "local");
+    let session_user = storage.getItem("user", "session");
+    if (local_user) {
+      let customer = JSON.parse(local_user);
+      api.WAApi.defaults.headers.common["x-customer-token"] = customer.token;
+      setUser(customer);
+    } else if (session_user) {
+      let session_customer = JSON.parse(session_user);
+      api.WAApi.defaults.headers.common["x-customer-token"] = session_customer.token;
+      setUser(session_customer);
+    }
+    setLoadingUser(false);
+  }, []);
+  react.useEffect(() => {
+    if (user) {
+      setLoadingToken(true);
+      try {
+        if (user?.token) {
+          api.WAApi.defaults.headers.common["x-customer-token"] = user.token;
+          setToken(user.token);
+        }
+      } catch (error) {
+        console.log("User not available");
+      } finally {
+        setLoadingToken(false);
+      }
+    }
+  }, [user]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    AuthContext.Provider,
+    {
+      value: {
+        signIn,
+        signOut,
+        user,
+        setUser,
+        customerSession,
+        loadingToken,
+        loadingUser,
+        token
+      },
+      children: loading ? null : props.children
+    }
+  );
+};
+var useAuth = () => react.useContext(AuthContext);
+var BusinessMediaContext = react.createContext({});
+var BusinessMediaProvider = (props) => {
+  const [businessMedia, setBusinessMeadia] = react.useState({});
+  const fetchBusinessMedia = async () => {
+    const response = await api.api.getBusinessMedia();
+    setBusinessMeadia({ ...response });
+  };
+  const updateBusinessMedia = (data) => {
+    setBusinessMeadia({ ...data });
+  };
+  react.useEffect(() => {
+    fetchBusinessMedia();
+  }, []);
+  return /* @__PURE__ */ jsxRuntime.jsx(BusinessMediaContext.Provider, { value: { businessMedia, updateBusinessMedia }, children: props.children });
+};
+var useBusinessMedia = () => react.useContext(BusinessMediaContext);
+var BusinessConfigContext = react.createContext({
+  currency: null,
+  reward_point_config: null,
+  orderConfig: null
+});
+var BusinessConfigProvider = ({
+  children,
+  data,
+  baseURL
+}) => {
+  api.WAApi.defaults.headers.common["business"] = data?.id;
+  api.WAApi.defaults.baseURL = baseURL;
+  const [loading, setLoading] = react.useState(true);
+  const { user } = useAuth();
+  const [currency, setCurrency] = react.useState({});
+  const [rewardPoint, setRewardPoint] = react.useState({});
+  const [orderConfig, setOrderConfig] = react.useState({});
+  const [domain, setDomain] = react.useState("");
+  const fetchData = async () => {
+    try {
+      const [business_setting, rewardPoint2, order_business_config] = await Promise.all([
+        api$1.getBusinessSetting(),
+        api$1.getRewardPointBusinessConfig(),
+        api$1.getOrderBusinessConfig()
+      ]);
+      setCurrency(business_setting.currency);
+      setDomain(business_setting.domain);
+      setRewardPoint(rewardPoint2);
+      setOrderConfig(order_business_config);
+    } catch (error) {
+      console.log("error in fetching data-->", error);
+    } finally {
+      setLoading(false);
+    }
+  };
+  react.useEffect(() => {
+    fetchData();
+  }, []);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    BusinessConfigContext.Provider,
+    {
+      value: {
+        ...data,
+        currency,
+        reward_point_config: rewardPoint,
+        domain,
+        orderConfig
+      },
+      children: loading ? null : children
+    }
+  );
+};
+var useBusinessContext = () => react.useContext(BusinessConfigContext);
+var useBusiness = () => react.useContext(BusinessConfigContext);
+var show = (type, message, options) => {
+  const defaultOptions = {
+    position: "top-right",
+    autoClose: 3e3
+  };
+  switch (type) {
+    case "success":
+      reactToastify.toast.success(message, {
+        ...defaultOptions,
+        ...options
+      });
+      break;
+    case "error":
+      reactToastify.toast.error(message, {
+        ...defaultOptions,
+        ...options
+      });
+      break;
+    case "info":
+      reactToastify.toast.info(message, {
+        ...defaultOptions,
+        ...options
+      });
+      break;
+    case "warning":
+      reactToastify.toast.warning(message, {
+        ...defaultOptions,
+        ...options
+      });
+      break;
+    case "default":
+      reactToastify.toast(message, {
+        ...defaultOptions,
+        ...options
+      });
+      break;
+    default:
+      reactToastify.toast(message, {
+        ...defaultOptions,
+        ...options
+      });
+      break;
+  }
+};
+var toast = {
+  success: (message, options) => show("success", message, options),
+  error: (message, options) => show("error", message, options),
+  info: (message, options) => show("info", message, options),
+  warning: (message, options) => show("warning", message, options),
+  default: (message, options) => show("default", message, options)
+};
+var CartWishlistRefreshContext = react.createContext({
+  refreshType: null,
+  setRefreshType: () => null
+});
+var CartWishlistRefreshProvider = (props) => {
+  const [refreshType, setRefreshType] = react.useState(null);
+  return /* @__PURE__ */ jsxRuntime.jsx(CartWishlistRefreshContext.Provider, { value: { refreshType, setRefreshType }, children: props.children });
+};
+var useCartWishlistRefresh = () => react.useContext(CartWishlistRefreshContext);
+var CartContext = react.createContext({
+  cartItems: [],
+  addToCart: () => null,
+  addToCartLoading: false,
+  addToCartError: null,
+  clearCart: () => null,
+  onChangeAddress: () => null,
+  onChangeTax: () => null,
+  onChangeOffer: () => null,
+  onChangeOrderType: () => null,
+  session: {},
+  removeAppliedOffer: () => null,
+  moveToWishlist: () => null,
+  moveToWishlistLoading: false,
+  orderFetchLoading: true,
+  onChangePromoCode: () => null,
+  onChangeGiftCard: () => null,
+  errorMessage: null
+});
+var CartProvider = (props) => {
+  const [cartItems, setCartItems] = react.useState([]);
+  const [orderFetchLoading, setOrderFetchLoading] = react.useState(true);
+  const [addToCartLoading, setAddToCartLoading] = react.useState(false);
+  const [addToCartError, setAddToCartError] = react.useState(null);
+  const [moveToWishlistLoading, setMoveToWishlistLoading] = react.useState(false);
+  const [session, setSession] = react.useState(null);
+  const [errorMessage, setErrorMessage] = react.useState(null);
+  const { user } = useAuth();
+  const storage = useStorage();
+  const { refreshType, setRefreshType } = useCartWishlistRefresh();
+  react.useEffect(() => {
+    if (refreshType == "cart") {
+      fetchOrderDetail();
+      setRefreshType(null);
+    }
+  }, [refreshType]);
+  const onChangeAddress = async (addressId, addressType) => {
+    let body = {};
+    if (addressType === "shipping") {
+      body = {
+        shipping_address: addressId
+      };
+    } else if (addressType === "billing") {
+      body = {
+        billing_address: addressId
+      };
+    } else {
+      body = {
+        shipping_address: addressId,
+        billing_address: addressId
+      };
+    }
+    try {
+      if (!orderFetchLoading && session && user) {
+        const response = await api.api.updateAddressCartOrder(body);
+        setSession({
+          ...session,
+          shipping_address: response.shipping_address,
+          billing_address: response.billing_address
+        });
+      }
+    } catch (error) {
+      console.log("Error---->", error);
+    }
+  };
+  const onChangePromoCode = async (promoCodeID) => {
+    let body = {
+      promo: promoCodeID
+    };
+    try {
+      if (!orderFetchLoading && session && user) {
+        const response = await api.api.updateCartPromoCode(body);
+        setSession({
+          ...session,
+          promo: response.promo,
+          promo_redeem_amount: Number(response.promo_redeem_amount),
+          final_payable_amount: Number(response.final_payable_amount)
+        });
+        if (promoCodeID) {
+          toast.success("Promo code applied successfully");
+        } else {
+          toast.info("Promo code removed");
+        }
+      }
+    } catch (error) {
+      setErrorMessage(error?.response?.message);
+      console.log("Error---->", error);
+      const errorMsg = error?.response?.message || "Failed to apply promo code";
+      toast.error(errorMsg);
+    }
+  };
+  const onChangeGiftCard = async (pin, code) => {
+    let body = {
+      pin,
+      code
+    };
+    try {
+      if (!orderFetchLoading && session && user) {
+        const response = await api.api.updateCartGiftCard(body);
+        setSession({
+          ...session,
+          giftcard: response.giftcard,
+          giftcard_redeem_amount: Number(response.giftcard_redeem_amount),
+          final_payable_amount: Number(response.final_payable_amount)
+        });
+        setErrorMessage(null);
+        fetchOrderDetail();
+      }
+    } catch (error) {
+      setErrorMessage(error?.response?.message);
+      console.log("Error---->", error);
+    }
+  };
+  const onChangeOffer = async (offers) => {
+    let body = {
+      offer: offers
+    };
+    try {
+      if (!orderFetchLoading && session && user) {
+        const response = await api.api.updateOfferCartOrder(body);
+        const orderData = await api.api.getOrderCartDetail();
+        setSession({
+          ...session,
+          offers: response.offers,
+          final_payable_amount: Number(orderData.final_payable_amount),
+          offer_redeem_amount: Number(orderData.offer_redeem_amount)
+        });
+        if (offers) {
+          toast.success("Offer applied successfully");
+        } else {
+          toast.info("Offer removed");
+        }
+        fetchOrderDetail();
+      }
+    } catch (error) {
+      console.log("Error---->", error);
+      toast.error("Failed to apply offer");
+    }
+  };
+  const onChangeOrderType = async (type) => {
+    const prevType = session?.type;
+    setSession((prev) => ({
+      ...prev,
+      type
+    }));
+    let body = { type };
+    try {
+      const response = await api.api.updateCartOrderType(body);
+      setSession((prev) => ({
+        ...prev,
+        type: response?.type ?? type
+      }));
+    } catch (error) {
+      console.log("Error---->", error);
+      setSession((prev) => ({
+        ...prev,
+        type: prevType
+      }));
+      toast.error("Something went wrong! Please try again.");
+    }
+  };
+  const onChangeTax = async (legal_name, tax_number) => {
+    let body = {
+      tax_number,
+      legal_name
+    };
+    try {
+      if (!orderFetchLoading && session && user) {
+        const response = await api.api.updateTaxCartOrder(body);
+        setSession({
+          ...session,
+          tax: response
+        });
+      }
+    } catch (error) {
+      console.log("Error---->", error);
+    }
+  };
+  react.useEffect(() => {
+    session && storage.setItem("cart", JSON.stringify(session), "local");
+  }, [session]);
+  const fetchOrderDetail = async () => {
+    setOrderFetchLoading(true);
+    const response = await api.api.getOrderCartDetail();
+    setSession({
+      ...session,
+      ...response
+    });
+    setCartItems(response.products);
+    setOrderFetchLoading(false);
+  };
+  react.useEffect(() => {
+    fetchOrderDetail();
+  }, [user]);
+  const removeAppliedOffer = async () => {
+    setSession({
+      ...session,
+      offers: null,
+      offer_redeem_amount: 0
+    });
+    toast.info("Offer removed");
+  };
+  const addToCart = async (sku, quantity) => {
+    setAddToCartLoading(true);
+    setAddToCartError(null);
+    setOrderFetchLoading(true);
+    let isItemInCart = cartItems?.find((item) => item.sku.id == sku);
+    try {
+      if (quantity === 0) {
+        if (isItemInCart) {
+          await api.api.deleteCartItem(isItemInCart.id);
+          console.log("Item removed from cart");
+          setCartItems(
+            cartItems?.filter(
+              (cartItem) => cartItem.id !== isItemInCart.id
+            )
+          );
+          await fetchOrderDetail();
+        }
+        return;
+      }
+      if (isItemInCart) {
+        await api.api.updateCartItem(isItemInCart.id, {
+          sku: isItemInCart.sku.id,
+          qty: isItemInCart.qty + quantity
+        });
+        await fetchOrderDetail();
+        console.log("Cart item updated successfully");
+      } else {
+        let body = {
+          qty: quantity,
+          sku
+        };
+        await api.api.addProductToCart(body);
+        console.log("New item added to cart.");
+        toast.success("Item added to cart");
+        await fetchOrderDetail();
+      }
+    } catch (error) {
+      setOrderFetchLoading(false);
+      console.log("Error---->", error);
+      const message = error?.response?.message || error?.response?.data?.message || error?.message || "Unable to add to cart. Please try again.";
+      setAddToCartError(message);
+      toast.error(message);
+    } finally {
+      setAddToCartLoading(false);
+    }
+  };
+  const clearCart = () => {
+    setCartItems([]);
+    setSession(null);
+    storage.removeItem("cart");
+    fetchOrderDetail();
+  };
+  const moveToWishlist = async (id) => {
+    let isItemInCart = cartItems?.find((item) => item.id === id);
+    if (!isItemInCart) {
+      console.log("Item not found in cart.");
+      toast.warning("Item not found in cart");
+      return;
+    }
+    try {
+      setMoveToWishlistLoading(true);
+      let body = { sku: isItemInCart.sku.id };
+      await api.api.addProductToWishlist(body);
+      await api.api.deleteCartItem(isItemInCart.id);
+      setCartItems(
+        (prevCartItems) => prevCartItems.filter((cartItem) => cartItem.id !== isItemInCart.id)
+      );
+      toast.success("Item moved to wishlist");
+      setRefreshType("wishlist");
+    } catch (error) {
+      console.error("Error moving item to wishlist:", error);
+      const errorMessage2 = error?.response?.data?.message || error?.response?.message || "Something went wrong! Please try again.";
+      toast.error(errorMessage2);
+    } finally {
+      setMoveToWishlistLoading(false);
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    CartContext.Provider,
+    {
+      value: {
+        cartItems,
+        addToCart,
+        addToCartLoading,
+        addToCartError,
+        clearCart,
+        onChangeAddress,
+        onChangeTax,
+        onChangeOffer,
+        onChangeOrderType,
+        session,
+        removeAppliedOffer,
+        moveToWishlist,
+        moveToWishlistLoading,
+        orderFetchLoading,
+        onChangePromoCode,
+        onChangeGiftCard,
+        errorMessage
+      },
+      children: props.children
+    }
+  );
+};
+var useCart = () => react.useContext(CartContext);
+var FilterContext = react.createContext({
+  selectedCategoryId: [],
+  addCategoryFilterId: () => null,
+  removeCategoryFilterId: () => null,
+  menuList: [],
+  productLoading: true,
+  currentPage: 1,
+  handlePageChange: () => null,
+  setMenuList: () => null,
+  filterConfig: null,
+  setSelectedSortOption: () => null,
+  seletedRattingNumber: 0,
+  setSelectedRattingNumber: () => null,
+  selectedDiscountOff: 0,
+  setSelectedDiscountOff: () => null,
+  selectedMinPrice: 0,
+  selectedMaxPrice: 0,
+  setSelectedMinPrice: () => null,
+  setSelectedMaxPrice: () => null,
+  brandList: [],
+  selectedBrandId: [],
+  updateBrandIds: () => null,
+  brandLoading: false,
+  variantList: [],
+  selectedVariants: [],
+  updateSelectedVariants: () => null,
+  variantLoading: false,
+  total: 0,
+  limit: 10,
+  offset: 0
+});
+var FilterProvider = (props) => {
+  const [filterConfig, setFilterConfig] = react.useState();
+  const [selectedCategoryId, setSelectedCategoryId] = react.useState([]);
+  const [selectedSortOption, setSelectedSortOption] = react.useState("newest_first");
+  const [seletedRattingNumber, setSelectedRattingNumber] = react.useState();
+  const [selectedDiscountOff, setSelectedDiscountOff] = react.useState();
+  const [selectedMinPrice, setSelectedMinPrice] = react.useState(
+    filterConfig?.price?.min
+  );
+  const [selectedMaxPrice, setSelectedMaxPrice] = react.useState(
+    filterConfig?.price?.max
+  );
+  const [menuList, setMenuList] = react.useState([]);
+  const [productLoading, setProductLoading] = react.useState(true);
+  const [currentPage, setCurrentPage] = react.useState(1);
+  const [filterConfigLoading, setFilterConfigLoading] = react.useState(false);
+  const [brandList, setBrandList] = react.useState([]);
+  const [selectedBrandId, setSelectedBrandId] = react.useState([]);
+  const [brandLoading, setBrandLoading] = react.useState(false);
+  const [variantList, setVariantList] = react.useState([]);
+  const [selectedVariants, setSelectedVariants] = react.useState([]);
+  const [variantLoading, setVariantLoading] = react.useState(false);
+  const [limit, setLimit] = react.useState(10);
+  const [offset, setOffset] = react.useState(0);
+  const [total, setTotal] = react.useState(0);
+  const fetchBrandList = async () => {
+    setBrandLoading(true);
+    let body = {
+      category_ids: selectedCategoryId
+    };
+    try {
+      const brands = await api.api.getBrandList(body);
+      setBrandList(brands);
+    } catch (error) {
+      console.log(error);
+    } finally {
+      setBrandLoading(false);
+    }
+  };
+  const addCategoryFilterId = (id) => {
+    setSelectedCategoryId((prevIds) => {
+      if (prevIds.includes(id)) {
+        return prevIds;
+      }
+      return [...prevIds, id];
+    });
+    setCurrentPage(1);
+  };
+  const fetchFilterConfig = async () => {
+    setFilterConfigLoading(true);
+    const response = await api.api.getProductFilterConfig();
+    setFilterConfig(response);
+    setFilterConfigLoading(false);
+  };
+  react.useEffect(() => {
+    fetchFilterConfig();
+  }, []);
+  const removeCategoryFilterId = (id) => {
+    setSelectedCategoryId((x) => {
+      return x.filter((o) => o !== id);
+    });
+    setCurrentPage(1);
+  };
+  const fetchProductList = async () => {
+    setProductLoading(true);
+    let body = {
+      category_id: selectedCategoryId,
+      sort_by: selectedSortOption,
+      min_rating: seletedRattingNumber,
+      min_discount: selectedDiscountOff,
+      min_price: selectedMinPrice,
+      max_price: selectedMaxPrice,
+      brand_ids: selectedCategoryId.length > 0 ? selectedBrandId : null,
+      variants: selectedCategoryId.length > 0 ? selectedVariants : null,
+      limit,
+      offset
+    };
+    try {
+      const productSearch = await api.api.getProductSearch(body);
+      setTotal(productSearch.count);
+      setMenuList(productSearch.results);
+    } catch (error) {
+      console.log(error);
+    } finally {
+      setProductLoading(false);
+    }
+  };
+  const updateBrandIds = (id) => {
+    setSelectedBrandId((prevIds) => {
+      if (prevIds.includes(id)) {
+        return prevIds.filter((x) => x !== id);
+      }
+      return [...prevIds, id];
+    });
+  };
+  const updateSelectedVariants = (label) => {
+    setSelectedVariants((prevVariants) => {
+      if (prevVariants.includes(label)) {
+        return prevVariants.filter((x) => x !== label);
+      }
+      return [...prevVariants, label];
+    });
+  };
+  const fetchVariantList = async () => {
+    setVariantLoading(true);
+    let body = {
+      category_ids: selectedCategoryId
+    };
+    const response = await api.api.getProductVariantByCategory(body);
+    setVariantList(response);
+    setVariantLoading(false);
+  };
+  react.useEffect(() => {
+    if (!filterConfigLoading) {
+      fetchProductList();
+    }
+  }, [
+    selectedCategoryId,
+    currentPage,
+    selectedSortOption,
+    seletedRattingNumber,
+    selectedDiscountOff,
+    selectedMinPrice,
+    selectedMaxPrice,
+    selectedBrandId,
+    selectedVariants,
+    limit,
+    offset
+  ]);
+  const handlePageChange = (newOffset) => {
+    setOffset(newOffset);
+  };
+  react.useEffect(() => {
+    if (selectedCategoryId.length > 0) {
+      fetchBrandList();
+      fetchVariantList();
+    }
+  }, [selectedCategoryId]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    FilterContext.Provider,
+    {
+      value: {
+        selectedCategoryId,
+        setMenuList,
+        addCategoryFilterId,
+        removeCategoryFilterId,
+        menuList,
+        productLoading,
+        currentPage,
+        handlePageChange,
+        filterConfig,
+        setSelectedSortOption,
+        seletedRattingNumber,
+        setSelectedRattingNumber,
+        selectedDiscountOff,
+        setSelectedDiscountOff,
+        selectedMinPrice,
+        selectedMaxPrice,
+        setSelectedMinPrice,
+        setSelectedMaxPrice,
+        brandList,
+        selectedBrandId,
+        updateBrandIds,
+        brandLoading,
+        variantList,
+        selectedVariants,
+        updateSelectedVariants,
+        variantLoading,
+        total,
+        limit,
+        offset
+      },
+      children: !filterConfigLoading && props.children
+    }
+  );
+};
+var useFilter = () => react.useContext(FilterContext);
+var ProductDetailContext = react.createContext({
+  selectedVariants: [],
+  selectUnselectVariants: () => null,
+  productDetail: [],
+  waitProductLoading: true,
+  setSelectedVariants: () => null
+});
+var ProductDetailProvider = (props) => {
+  const [selectedVariants, setSelectedVariants] = react.useState([]);
+  const [productDetail, setProductDetail] = react.useState([]);
+  const [waitProductLoading, setWaitProductLoading] = react.useState(true);
+  const selectedIds = props?.selected_variants?.split(",").map(Number);
+  const selectUnselectVariants = (type, value, id) => {
+    setWaitProductLoading(true);
+    setSelectedVariants((prev) => {
+      const existingIndex = prev.findIndex((item) => item.type === type);
+      if (existingIndex > -1) {
+        const updatedVariants = [...prev];
+        updatedVariants[existingIndex] = { type, value, id };
+        return updatedVariants;
+      } else {
+        const newVariants = [...prev, { type, value, id }];
+        return newVariants;
+      }
+    });
+    setTimeout(() => {
+      setWaitProductLoading(false);
+    }, 1e3);
+  };
+  react.useEffect(() => {
+    (async () => {
+      setWaitProductLoading(true);
+      try {
+        const productDetail2 = await api.api.getProductDetail(props.productId);
+        setProductDetail(productDetail2);
+        if (props.selected_variants !== null) {
+          const initialV = productDetail2?.variant?.map((vType) => {
+            const matchedVariant = vType.variants.find(
+              (variant) => selectedIds.includes(variant.id)
+            );
+            if (matchedVariant) {
+              return {
+                id: matchedVariant.id,
+                type: vType.variant_type.type,
+                value: matchedVariant.label
+              };
+            }
+            return null;
+          }).filter(Boolean);
+          setSelectedVariants(initialV || []);
+        } else {
+          let initialV = productDetail2.variant.map((vType) => {
+            return {
+              id: vType.variants[0].id,
+              type: vType.variant_type.type,
+              value: vType.variants[0].label
+            };
+          });
+          setSelectedVariants(initialV || []);
+        }
+      } catch (error) {
+        console.error("Error loading product details:", error);
+      } finally {
+        setWaitProductLoading(false);
+      }
+    })();
+  }, [props.productId]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    ProductDetailContext.Provider,
+    {
+      value: {
+        selectedVariants,
+        setSelectedVariants,
+        selectUnselectVariants,
+        productDetail,
+        waitProductLoading
+      },
+      children: props.children
+    }
+  );
+};
+var useProductDetail = () => react.useContext(ProductDetailContext);
+
+// src/tailwind/applyTheme.ts
+function applyTheme(themeRGB) {
+  const themeObject = mapTheme(themeRGB);
+  const root = document.documentElement;
+  Object.keys(themeObject).forEach((v) => {
+    const propertyVal = themeObject[v];
+    const validation = validateRGB(propertyVal);
+    if (!validation) {
+      throw new Error(`Invalid RGB value for ${v}: ${propertyVal}`);
+    }
+    root.style.setProperty(v, propertyVal);
+  });
+}
+function mapTheme(rgb) {
+  return {
+    "--color-primary": rgb["primary"] ?? ""
+  };
+}
+function validateRGB(rgb) {
+  if (!rgb) return true;
+  const rgbRegex = /^(\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3})$/;
+  return rgbRegex.test(rgb);
+}
+function hexToRgb(hex) {
+  var result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+  return result ? `${parseInt(result[1], 16).toString()},${parseInt(result[2], 16).toString()},${parseInt(result[3], 16).toString()}` : null;
+}
+var ThemeContext = react.createContext({
+  themeRGB: {}
+});
+function ThemeProvider(props) {
+  const config = react.useContext(BusinessConfigContext);
+  const { theme } = config;
+  const pcolor = hexToRgb(theme?.primary_color);
+  const primaryColor = !!pcolor ? pcolor : "0, 72, 76";
+  react.useEffect(() => {
+    applyTheme({ primary: primaryColor });
+  }, []);
+  const value = react.useMemo(() => {
+    return { themeRGB: { primary: primaryColor } };
+  }, [primaryColor]);
+  return /* @__PURE__ */ jsxRuntime.jsx(ThemeContext.Provider, { value, children: props.children });
+}
+var useTheme = () => react.useContext(ThemeContext);
+var ProductConfigContext = react.createContext({});
+var ProductConfigProvider = (props) => {
+  const [productConfig, setProductConfig] = react.useState({});
+  const fetchProductConfig = async () => {
+    const response = await api.api.getProductConfig();
+    setProductConfig({ ...response });
+  };
+  const updateProductConfig = (data) => {
+    setProductConfig({ ...data });
+  };
+  react.useEffect(() => {
+    fetchProductConfig();
+  }, []);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    ProductConfigContext.Provider,
+    {
+      value: { productConfig, updateProductConfig },
+      children: props.children
+    }
+  );
+};
+var useProductConfig = () => react.useContext(ProductConfigContext);
+var CustomerConfigContext = react.createContext({ customerConfig: null });
+var CustomerConfigProvider = (props) => {
+  const [customerConfig, setCustomerConfig] = react.useState();
+  const [loading, setLoading] = react.useState(false);
+  const fetchCustomerConfig = async () => {
+    setLoading(true);
+    try {
+      const response = await api.api.getCustomerBusinessConfig();
+      setCustomerConfig(response);
+    } catch (error) {
+      console.log("Error in fetching customer config---->", error);
+    }
+    setLoading(false);
+  };
+  react.useEffect(() => {
+    fetchCustomerConfig();
+  }, []);
+  return /* @__PURE__ */ jsxRuntime.jsx(CustomerConfigContext.Provider, { value: { customerConfig }, children: loading ? null : props.children });
+};
+var useCustomer = () => react.useContext(CustomerConfigContext);
+var ThemeEditContext = react.createContext({
+  token: "",
+  isThemeEdit: false,
+  isHeader: false,
+  isFooter: false,
+  isAnnouncementBar: false
+});
+var ThemeEditProvider = (props) => {
+  const [isThemeEdit, setIsThemeEdit] = react.useState(props.isThemeEdit);
+  const [token, setToken] = react.useState(props.token);
+  const [isHeader, setIsHeader] = react.useState(props.isHeader);
+  const [isFooter, setIsFooter] = react.useState(props.isFooter);
+  const [isAnnouncementBar, setIsAnnouncementBar] = react.useState(props.isAnnouncementBar);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    ThemeEditContext.Provider,
+    {
+      value: { token, isThemeEdit, isHeader, isFooter, isAnnouncementBar },
+      children: props.children
+    }
+  );
+};
+var useThemeEdit = () => react.useContext(ThemeEditContext);
+var HomeConfigContext = react.createContext({
+  selectedConfig: [],
+  setSelectedConfig: () => null,
+  addConfig: () => null,
+  updateConfig: () => null,
+  removeConfig: () => null,
+  moveConfig: () => null,
+  themeConfigData: {},
+  loading: true
+});
+var HomeConfigProvider = (props) => {
+  const [selectedConfig, setSelectedConfig] = react.useState([]);
+  const { token } = useThemeEdit();
+  const themeConfig = react.useContext(BusinessConfigContext);
+  const [themeConfigData, setThemeConfigData] = react.useState({});
+  const [isInitialized, setIsInitialized] = react.useState(false);
+  const updateRef = react.useRef(false);
+  const [loading, setLoading] = react.useState(true);
+  const getThemeConfig = react.useCallback(async () => {
+    setLoading(true);
+    try {
+      const response = await api$1.retrieveThemeContent(
+        themeConfig.theme.id,
+        props.page
+      );
+      setThemeConfigData(response);
+      if (response?.data && Array.isArray(response.data)) {
+        setSelectedConfig(
+          response.data.filter(
+            (item) => item !== null && item !== void 0
+          )
+        );
+      }
+      setIsInitialized(true);
+    } catch (error) {
+      console.error("Error fetching theme content:", error);
+    } finally {
+      setLoading(false);
+    }
+  }, [themeConfig.theme.id]);
+  const onUpdateThemeContent = react.useCallback(
+    async (configToUpdate = selectedConfig) => {
+      try {
+        const body = {
+          data: configToUpdate,
+          slug: props.page,
+          platform: typeof window !== "undefined" ? "website" : "app"
+        };
+        if (updateRef.current) return;
+        updateRef.current = true;
+        await api$1.updateThemeContent(
+          body,
+          themeConfig?.theme?.id,
+          props.page,
+          token
+        );
+        const updatedResponse = await api$1.retrieveThemeContent(
+          themeConfig.theme.id,
+          props.page
+        );
+        setThemeConfigData(updatedResponse);
+      } catch (error) {
+        console.error("Error updating theme content:", error);
+      } finally {
+        updateRef.current = false;
+      }
+    },
+    [isInitialized, token, themeConfig?.theme?.id, selectedConfig]
+  );
+  const addConfig = react.useCallback(
+    async (config) => {
+      setSelectedConfig((prev) => {
+        const newConfig = [...prev, config];
+        onUpdateThemeContent(newConfig);
+        return newConfig;
+      });
+    },
+    [onUpdateThemeContent]
+  );
+  const updateConfig = react.useCallback(
+    async (config, index) => {
+      setSelectedConfig((prev) => {
+        const newConfig = [...prev];
+        newConfig[index] = config;
+        onUpdateThemeContent(newConfig);
+        return newConfig;
+      });
+    },
+    [onUpdateThemeContent]
+  );
+  const moveConfig = react.useCallback(
+    (fromIndex, toIndex) => {
+      setSelectedConfig((prev) => {
+        const newConfig = [...prev];
+        const [movedItem] = newConfig.splice(fromIndex, 1);
+        newConfig.splice(toIndex, 0, movedItem);
+        onUpdateThemeContent(newConfig);
+        return newConfig;
+      });
+    },
+    [onUpdateThemeContent]
+  );
+  const removeConfig = react.useCallback(
+    async (index) => {
+      setSelectedConfig((prev) => {
+        const newConfig = prev.filter((_2, i) => i !== index);
+        onUpdateThemeContent(newConfig);
+        return newConfig;
+      });
+    },
+    [onUpdateThemeContent]
+  );
+  react.useEffect(() => {
+    getThemeConfig();
+  }, [getThemeConfig]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    HomeConfigContext.Provider,
+    {
+      value: {
+        selectedConfig,
+        setSelectedConfig,
+        addConfig,
+        updateConfig,
+        removeConfig,
+        moveConfig,
+        themeConfigData,
+        loading
+      },
+      children: props.children
+    }
+  );
+};
+var useHomeConfig = () => react.useContext(HomeConfigContext);
+var CustomPageConfigContext = react.createContext({
+  selectedConfig: [],
+  setSelectedConfig: () => null,
+  addConfig: () => null,
+  updateConfig: () => null,
+  removeConfig: () => null,
+  moveConfig: () => null,
+  loading: true
+});
+var CustomPageConfigProvider = (props) => {
+  const { token } = useThemeEdit();
+  const [selectedConfig, setSelectedConfig] = react.useState([]);
+  const [loading, setLoading] = react.useState(true);
+  const updateRef = react.useRef(false);
+  const load = react.useCallback(async () => {
+    setLoading(true);
+    try {
+      const row = await api$1.getCustomPageContent(props.pageId, token);
+      const data = row?.content;
+      setSelectedConfig(Array.isArray(data) ? data.filter((x) => x != null) : []);
+    } catch (e) {
+      console.error("Error loading custom page content:", e);
+    } finally {
+      setLoading(false);
+    }
+  }, [props.pageId, token]);
+  const persist = react.useCallback(
+    async (configToSave) => {
+      try {
+        if (updateRef.current) return;
+        updateRef.current = true;
+        await api$1.updateCustomPageContent(props.pageId, configToSave, token);
+        await load();
+      } catch (e) {
+        console.error("Error saving custom page content:", e);
+      } finally {
+        updateRef.current = false;
+      }
+    },
+    [props.pageId, token, load]
+  );
+  const addConfig = react.useCallback(
+    async (config) => {
+      setSelectedConfig((prev) => {
+        const next = [...prev, config];
+        persist(next);
+        return next;
+      });
+    },
+    [persist]
+  );
+  const updateConfig = react.useCallback(
+    async (config, index) => {
+      setSelectedConfig((prev) => {
+        const next = [...prev];
+        next[index] = config;
+        persist(next);
+        return next;
+      });
+    },
+    [persist]
+  );
+  const moveConfig = react.useCallback(
+    (fromIndex, toIndex) => {
+      setSelectedConfig((prev) => {
+        const next = [...prev];
+        const [moved] = next.splice(fromIndex, 1);
+        next.splice(toIndex, 0, moved);
+        persist(next);
+        return next;
+      });
+    },
+    [persist]
+  );
+  const removeConfig = react.useCallback(
+    async (index) => {
+      setSelectedConfig((prev) => {
+        const next = prev.filter((_2, i) => i !== index);
+        persist(next);
+        return next;
+      });
+    },
+    [persist]
+  );
+  react.useEffect(() => {
+    load();
+  }, [load]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    CustomPageConfigContext.Provider,
+    {
+      value: {
+        selectedConfig,
+        setSelectedConfig,
+        addConfig,
+        updateConfig,
+        removeConfig,
+        moveConfig,
+        loading
+      },
+      children: props.children
+    }
+  );
+};
+var useCustomPageConfig = () => react.useContext(CustomPageConfigContext);
+var WishlistContext = react.createContext({
+  wishlistItems: [],
+  addToWishlist: () => null,
+  deleteWishlistItem: () => {
+  },
+  moveToCart: () => {
+  },
+  fetchWishlistLoading: false,
+  addToWishlistLoading: false,
+  moveToCartLoading: false
+});
+var WishlistProvider = (props) => {
+  const [wishlistItems, setWishlistItems] = react.useState([]);
+  const { user } = useAuth();
+  const [fetchWishlistLoading, setFetchWishlistLoading] = react.useState(true);
+  const [addToWishlistLoading, setAddToWishlistLoading] = react.useState(false);
+  const [moveToCartLoading, setMoveToCartLoading] = react.useState(false);
+  const { addToCart } = useCart();
+  const { refreshType, setRefreshType } = useCartWishlistRefresh();
+  react.useEffect(() => {
+    if (refreshType == "wishlist") {
+      fetchWishlistDetail();
+      setRefreshType(null);
+    }
+  }, [refreshType]);
+  const fetchWishlistDetail = async () => {
+    if (!!user) {
+      setFetchWishlistLoading(true);
+      try {
+        const response = await api.api.getWishlist();
+        console.log("fetchWishlistDetail response:", response);
+        setWishlistItems(response);
+        return response;
+      } catch (error) {
+        console.error("Error fetching wishlist details:", error);
+        return null;
+      } finally {
+        setFetchWishlistLoading(false);
+      }
+    }
+  };
+  react.useEffect(() => {
+    user && user.is_active && fetchWishlistDetail();
+  }, [user]);
+  const addToWishlist = async (sku) => {
+    try {
+      setAddToWishlistLoading(true);
+      let body = {
+        sku
+      };
+      await api.api.addProductToWishlist(body);
+      console.log("New item added to Wishlist");
+      toast.success("Item added to wishlist");
+      fetchWishlistDetail();
+    } catch (error) {
+      console.log("error==", error);
+      const errorMessage = error?.response?.data?.message || error?.response?.message || "Something went wrong! Please try again.";
+      toast.error(errorMessage);
+    } finally {
+      setAddToWishlistLoading(false);
+    }
+  };
+  const deleteWishlistItem = async (id) => {
+    try {
+      setFetchWishlistLoading(true);
+      const response = await api.api.deleteWishlist(id);
+      console.log("Item deleted:", response);
+      setWishlistItems((prevItems) => prevItems.filter((item) => item.id !== id));
+      toast.success("Item removed from wishlist");
+      await fetchWishlistDetail();
+    } catch (error) {
+      console.log("Error deleting item:", error);
+      toast.error("Failed to remove item from wishlist");
+    } finally {
+      setFetchWishlistLoading(false);
+    }
+  };
+  const moveToCart = async (id, quantity) => {
+    let isItemInWishlist = wishlistItems?.find((item) => item.id === id);
+    if (!isItemInWishlist) {
+      console.log("Item not found in wishlist.");
+      toast.warning("Item not found in wishlist");
+      return;
+    }
+    try {
+      setMoveToCartLoading(true);
+      addToCart(isItemInWishlist.sku.id, quantity);
+      await api.api.deleteWishlist(isItemInWishlist.id);
+      setWishlistItems(wishlistItems?.filter((item) => item.id !== isItemInWishlist.id));
+      setRefreshType("cart");
+    } catch (error) {
+      console.log("Error moving item to cart:", error);
+      const errorMessage = error?.response?.data?.message || error?.response?.message || error?.message || "";
+      const errorMsg = errorMessage || "Failed to move item to cart";
+      toast.error(errorMsg);
+    } finally {
+      setMoveToCartLoading(false);
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(WishlistContext.Provider, { value: { wishlistItems, addToWishlist, deleteWishlistItem, moveToCart, fetchWishlistLoading, addToWishlistLoading, moveToCartLoading }, children: props.children });
+};
+var useWishlist = () => react.useContext(WishlistContext);
+function LiveSupportWidget() {
+  const { config, loading } = useLiveSupportWidget();
+  if (loading || !config?.is_active || config?.type !== "whatsapp" || !config?.whatsapp_no?.trim()) {
+    return null;
+  }
+  const phone = config.whatsapp_no.replace(/\D/g, "");
+  const whatsappUrl = `https://wa.me/${phone}`;
+  const handleClick = () => {
+    window.open(whatsappUrl, "_blank", "noopener,noreferrer");
+  };
+  console.log(config);
+  console.log(loading);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "button",
+    {
+      type: "button",
+      onClick: handleClick,
+      style: {
+        bottom: "15px"
+      },
+      className: "fixed bottom-6 fixed right-6 z-[9999] flex h-14 w-14 items-center justify-center rounded-full bg-[#25D366] text-white shadow-lg transition-transform hover:scale-105 focus:outline-none focus:ring-2 focus:ring-[#25D366] focus:ring-offset-2",
+      "aria-label": "Chat on WhatsApp",
+      children: /* @__PURE__ */ jsxRuntime.jsx(fa.FaWhatsapp, { className: "h-8 w-8" })
+    }
+  );
+}
+var BaseProvider = ({
+  children,
+  baseURL,
+  token,
+  isEdit,
+  businessConfig,
+  storage,
+  isHeader,
+  isFooter,
+  isAnnouncementBar,
+  referralCodeFromUrl = null
+}) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(StorageProvider, { storage, children: /* @__PURE__ */ jsxRuntime.jsx(BusinessConfigProvider, { data: businessConfig, baseURL, children: /* @__PURE__ */ jsxRuntime.jsx(ReferralCodeProvider, { referralCodeFromUrl, children: /* @__PURE__ */ jsxRuntime.jsx(ThemeEditProvider, { isThemeEdit: isEdit, token, isHeader, isFooter, isAnnouncementBar, children: /* @__PURE__ */ jsxRuntime.jsx(BusinessMediaProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(CustomerConfigProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(AuthProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(ModalProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(ThemeProvider, { children: /* @__PURE__ */ jsxRuntime.jsxs(LiveSupportWidgetProvider, { children: [
+    businessConfig.category.type == "retail" ? /* @__PURE__ */ jsxRuntime.jsx(ProductConfigProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(CartWishlistRefreshProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(CartProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(WishlistProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(FilterProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children }) }) }) }) }) }) : /* @__PURE__ */ jsxRuntime.jsx(MenuCartProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(MenuFilterProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children }) }) }),
+    /* @__PURE__ */ jsxRuntime.jsx(LiveSupportWidget, {})
+  ] }) }) }) }) }) }) }) }) }) });
+};
+var ModalContext = react.createContext(void 0);
+var ModalProvider = ({ children }) => {
+  const [openModal, setOpenModal] = react.useState("");
+  const [userData, setUserData] = react.useState({});
+  const showModal = (modal) => setOpenModal(modal);
+  const closeModal = () => setOpenModal("");
+  const clearUserData = () => setUserData({});
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    ModalContext.Provider,
+    {
+      value: {
+        openModal,
+        showModal,
+        closeModal,
+        userData,
+        setUserData,
+        clearUserData
+      },
+      children
+    }
+  );
+};
+var useModal = () => {
+  const context = react.useContext(ModalContext);
+  if (!context) {
+    throw new Error("useModal must be used within a ModalProvider");
+  }
+  return context;
+};
+var HomeConfigHeroSliderContext = react.createContext({
+  loading: true,
+  heroSliderConfigData: [],
+  onUpdateHeroSlider: () => null
+});
+var HomeConfigHeroSliderProvider = (props) => {
+  const [loading, setLoading] = react.useState(true);
+  const [heroSliderConfigData, setHeroSliderConfigData] = react.useState([]);
+  const { token } = useThemeEdit();
+  const themeConfig = react.useContext(BusinessConfigContext);
+  const getHeroSliderConfig = async () => {
+    setLoading(true);
+    try {
+      const response = await api$1.retrieveThemeContent(
+        themeConfig.theme.id,
+        "hero_slider"
+      );
+      setHeroSliderConfigData(response.data);
+    } finally {
+      setLoading(false);
+    }
+  };
+  react.useEffect(() => {
+    getHeroSliderConfig();
+  }, []);
+  const onUpdateHeroSlider = async (configToUpdate) => {
+    setLoading(true);
+    try {
+      const body = {
+        data: configToUpdate,
+        slug: "hero_slider",
+        platform: typeof window !== "undefined" ? "website" : "app"
+      };
+      await api$1.updateThemeContent(
+        body,
+        themeConfig?.theme?.id,
+        "hero_slider",
+        token
+      );
+      const updatedResponse = await api$1.retrieveThemeContent(
+        themeConfig.theme.id,
+        "hero_slider"
+      );
+      setHeroSliderConfigData(updatedResponse.data);
+    } catch (error) {
+      console.error("Error updating theme content:", error);
+    } finally {
+      setLoading(false);
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    HomeConfigHeroSliderContext.Provider,
+    {
+      value: { loading, heroSliderConfigData, onUpdateHeroSlider },
+      children: props.children
+    }
+  );
+};
+var useHomeConfigHeroSlider = () => react.useContext(HomeConfigHeroSliderContext);
+var HeaderFooterContext = react.createContext({
+  headerConfig: {},
+  footerConfig: {},
+  onUpdateThemeContent: () => Promise.resolve(),
+  loading: false,
+  announcementConfig: {}
+});
+var HeaderFooterProvider = (props) => {
+  const [headerConfig, setHeaderConfig] = react.useState({});
+  const [footerConfig, setFooterConfig] = react.useState({});
+  const [announcementConfig, setAnnouncementConfig] = react.useState({});
+  const { token } = useThemeEdit();
+  const themeConfig = useBusiness();
+  const [loading, setLoading] = react.useState(true);
+  const getThemeConfig = react.useCallback(async () => {
+    setLoading(true);
+    try {
+      const response = await api.api.retrieveThemeContent(
+        themeConfig.theme.id,
+        props.page
+      );
+      response.slug === "header" && setHeaderConfig(response.data);
+      response.slug === "footer" && setFooterConfig(response.data);
+      response.slug === "announcement" && setAnnouncementConfig(response.data);
+    } catch (error) {
+      console.error("Error fetching theme content:", error);
+    } finally {
+      setLoading(false);
+    }
+  }, [themeConfig.theme.id]);
+  const onUpdateThemeContent = react.useCallback(
+    async (configToUpdate) => {
+      try {
+        const body = {
+          data: configToUpdate,
+          slug: props.page,
+          platform: typeof window !== "undefined" ? "website" : "app"
+        };
+        await api.api.updateThemeContent(
+          body,
+          themeConfig.theme.id,
+          props.page,
+          token
+        );
+        const updatedResponse = await api.api.retrieveThemeContent(
+          themeConfig.theme.id,
+          props.page
+        );
+        updatedResponse.slug === "header" && setHeaderConfig(updatedResponse.data);
+        updatedResponse.slug === "footer" && setFooterConfig(updatedResponse.data);
+        updatedResponse.slug === "announcement" && setAnnouncementConfig(updatedResponse.data);
+      } catch (error) {
+        console.error("Error updating theme content:", error);
+      } finally {
+        setLoading(false);
+      }
+    },
+    [props.page]
+  );
+  react.useEffect(() => {
+    getThemeConfig();
+  }, [getThemeConfig]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    HeaderFooterContext.Provider,
+    {
+      value: { headerConfig, footerConfig, onUpdateThemeContent, loading, announcementConfig },
+      children: loading ? null : props.children
+    }
+  );
+};
+var useHeaderFooter = () => {
+  return react.useContext(HeaderFooterContext);
+};
+var MenuFilterContext = react.createContext({
+  menuList: [],
+  categoryList: [],
+  selectedCategoryId: [],
+  addCategoryFilterId: () => null,
+  removeCategoryFilterId: () => null,
+  menuLoading: true,
+  categoryLoading: true,
+  isInitialLoad: true,
+  currentPage: 1,
+  totalPages: 1,
+  handlePageChange: () => null,
+  setMenuList: () => null,
+  selectedSortOption: "newest_first",
+  setSelectedSortOption: () => null,
+  selectedMinPrice: void 0,
+  selectedMaxPrice: void 0,
+  setSelectedMinPrice: () => null,
+  setSelectedMaxPrice: () => null,
+  searchQuery: "",
+  setSearchQuery: () => null,
+  selectedFoodType: "",
+  setSelectedFoodType: () => null
+});
+var MenuFilterProvider = (props) => {
+  const [menuList, setMenuList] = react.useState([]);
+  const [categoryList, setCategoryList] = react.useState([]);
+  const [selectedCategoryId, setSelectedCategoryId] = react.useState([]);
+  const [selectedSortOption, setSelectedSortOption] = react.useState("newest_first");
+  const [selectedMinPrice, setSelectedMinPrice] = react.useState();
+  const [selectedMaxPrice, setSelectedMaxPrice] = react.useState();
+  const [menuLoading, setMenuLoading] = react.useState(true);
+  const [categoryLoading, setCategoryLoading] = react.useState(true);
+  const [isInitialLoad, setIsInitialLoad] = react.useState(true);
+  const [currentPage, setCurrentPage] = react.useState(1);
+  const [searchQuery, setSearchQuery] = react.useState("");
+  const [debouncedSearchQuery, setDebouncedSearchQuery] = react.useState("");
+  const [selectedFoodType, setSelectedFoodType] = react.useState("");
+  const limit = 12;
+  const [totalCount, setTotalCount] = react.useState(0);
+  const totalPages = Math.ceil(totalCount / limit);
+  const searchTimeoutRef = react.useRef(null);
+  const fetchCategoryList = async () => {
+    setCategoryLoading(true);
+    try {
+      const response = await api.api.getMenuCategories();
+      setCategoryList(response.data || response);
+    } catch (error) {
+      console.log("Error fetching categories:", error);
+    } finally {
+      setCategoryLoading(false);
+    }
+  };
+  const fetchMenuList = async () => {
+    setMenuLoading(true);
+    try {
+      let body = {
+        limit,
+        offset: (currentPage - 1) * limit
+      };
+      if (selectedCategoryId.length > 0) {
+        body.category_ids = selectedCategoryId.join(",");
+      }
+      if (selectedFoodType) {
+        body.food_type = selectedFoodType;
+      }
+      if (debouncedSearchQuery.trim()) {
+        body.search = debouncedSearchQuery;
+      }
+      const response = await api.api.getMenuList(body);
+      let filteredMenus = response.data || response;
+      if (filteredMenus && typeof filteredMenus === "object" && !Array.isArray(filteredMenus)) {
+        filteredMenus = filteredMenus.results || filteredMenus.data || filteredMenus.items || [];
+      }
+      if (!Array.isArray(filteredMenus)) {
+        filteredMenus = [];
+      }
+      setMenuList(filteredMenus);
+      setTotalCount(filteredMenus.length);
+    } catch (error) {
+      console.log("Error fetching menus:", error);
+    } finally {
+      setMenuLoading(false);
+      if (isInitialLoad) {
+        setIsInitialLoad(false);
+      }
+    }
+  };
+  const addCategoryFilterId = (id) => {
+    setSelectedCategoryId((prevIds) => {
+      if (prevIds.includes(id)) {
+        return prevIds;
+      }
+      return [...prevIds, id];
+    });
+    setCurrentPage(1);
+  };
+  const removeCategoryFilterId = (id) => {
+    setSelectedCategoryId((x) => {
+      return x.filter((o) => o !== id);
+    });
+    setCurrentPage(1);
+  };
+  const handlePageChange = (page) => {
+    setCurrentPage(page);
+  };
+  react.useEffect(() => {
+    if (searchTimeoutRef.current) {
+      clearTimeout(searchTimeoutRef.current);
+    }
+    searchTimeoutRef.current = setTimeout(() => {
+      setDebouncedSearchQuery(searchQuery);
+    }, 1e3);
+    return () => {
+      if (searchTimeoutRef.current) {
+        clearTimeout(searchTimeoutRef.current);
+      }
+    };
+  }, [searchQuery]);
+  react.useEffect(() => {
+    fetchCategoryList();
+  }, []);
+  react.useEffect(() => {
+    fetchMenuList();
+  }, [
+    selectedCategoryId,
+    currentPage,
+    selectedSortOption,
+    selectedMinPrice,
+    selectedMaxPrice,
+    debouncedSearchQuery,
+    selectedFoodType
+  ]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    MenuFilterContext.Provider,
+    {
+      value: {
+        menuList,
+        categoryList,
+        selectedCategoryId,
+        addCategoryFilterId,
+        removeCategoryFilterId,
+        menuLoading,
+        categoryLoading,
+        isInitialLoad,
+        currentPage,
+        totalPages,
+        handlePageChange,
+        setMenuList,
+        selectedSortOption,
+        setSelectedSortOption,
+        selectedMinPrice,
+        selectedMaxPrice,
+        setSelectedMinPrice,
+        setSelectedMaxPrice,
+        searchQuery,
+        setSearchQuery,
+        selectedFoodType,
+        setSelectedFoodType
+      },
+      children: props.children
+    }
+  );
+};
+var useMenuFilter = () => react.useContext(MenuFilterContext);
+var MenuCartContext = react.createContext({
+  menuCartItems: [],
+  cartLength: 0,
+  cartType: "delivery",
+  session: null,
+  errorMessage: null,
+  menuCartLoading: false,
+  promoCodeLoading: false,
+  updateOrderType: () => {
+  },
+  addMenuToCart: async () => {
+  },
+  updateMenuCartItem: async () => {
+  },
+  deleteMenuCartItem: async () => {
+  },
+  updateMenuCartPromoCode: async () => {
+  },
+  updateMenuCartAddress: async () => {
+  },
+  getMenuOrderCharge: async () => {
+  },
+  clearMenuCart: () => {
+  }
+});
+var MenuCartProvider = (props) => {
+  const [menuCartItems, setMenuCartItems] = react.useState([]);
+  const [cartLength, setCartLength] = react.useState(0);
+  const [cartType, setCartTypeState] = react.useState("delivery");
+  const [session, setSession] = react.useState(null);
+  const [errorMessage, setErrorMessage] = react.useState(null);
+  const [menuCartLoading, setMenuCartLoading] = react.useState(false);
+  const [promoCodeLoading, setPromoCodeLoading] = react.useState(false);
+  const { user } = useAuth();
+  const storage = useStorage();
+  const fetchMenuCartDetail = async () => {
+    setMenuCartLoading(true);
+    try {
+      const response = await api.api.getMenuCartDetail();
+      setMenuCartItems(response?.items || response?.products || []);
+      setCartLength(response?.items?.length || response?.products?.length || 0);
+      setCartTypeState(response?.type || "delivery");
+      setSession(response);
+    } catch (error) {
+      console.error("Error fetching menu cart:", error);
+      setMenuCartItems([]);
+      setCartLength(0);
+    } finally {
+      setMenuCartLoading(false);
+    }
+  };
+  react.useEffect(() => {
+    fetchMenuCartDetail();
+  }, [user]);
+  react.useEffect(() => {
+    setCartLength(menuCartItems.length);
+  }, [menuCartItems]);
+  react.useEffect(() => {
+    session && storage.setItem("menuCart", JSON.stringify(session), "local");
+  }, [session, storage]);
+  const updateOrderType = async (params) => {
+    setMenuCartLoading(true);
+    try {
+      const { type, pickup_time, table_no, shipping_address } = params;
+      const body = { type };
+      if (type === "pickup" && pickup_time) {
+        body.pickup_time = pickup_time;
+      }
+      if (type === "self_dinein" && table_no) {
+        body.table_no = table_no;
+      }
+      if (type === "delivery" && user && shipping_address) {
+        body.shipping_address = shipping_address;
+      }
+      await api.api.updateMenuCartType(body);
+      setCartTypeState(type);
+      fetchMenuCartDetail();
+    } catch (error) {
+      console.error("Failed to update cart type:", error);
+    } finally {
+      setMenuCartLoading(false);
+    }
+  };
+  const updateMenuCartPromoCode = async (promoCode) => {
+    let body = {
+      promo_code: promoCode
+    };
+    setPromoCodeLoading(true);
+    setErrorMessage(null);
+    try {
+      if (session) {
+        const response = await api.api.updateMenuCartPromoCode(body);
+        setSession({
+          ...session,
+          promo: response.promo,
+          promo_redeem_amount: Number(response.promo_redeem_amount),
+          final_payable_amount: Number(response.final_payable_amount)
+        });
+        await fetchMenuCartDetail();
+      }
+    } catch (error) {
+      setErrorMessage(error?.response?.data?.error || error?.message || "Failed to apply promo code");
+      console.error("Failed to update promo code:", error);
+    } finally {
+      setPromoCodeLoading(false);
+    }
+  };
+  const updateMenuCartAddress = async (shippingAddress) => {
+    setMenuCartLoading(true);
+    setErrorMessage(null);
+    try {
+      const body = {
+        shipping_address: shippingAddress
+      };
+      const response = await api.api.updateMenuOrderCartAddress(body);
+      setSession({
+        ...session,
+        shipping_address: response.shipping_address
+      });
+      await fetchMenuCartDetail();
+    } catch (error) {
+      setErrorMessage(error?.response?.data?.error || error?.message || "Failed to update address");
+      console.error("Failed to update menu cart address:", error);
+    } finally {
+      setMenuCartLoading(false);
+    }
+  };
+  const getMenuOrderCharge = async (orderId, body) => {
+    setMenuCartLoading(true);
+    setErrorMessage(null);
+    try {
+      const response = await api.api.getMenuOrderCharge(orderId, body);
+      return response;
+    } catch (error) {
+      setErrorMessage(error?.response?.data?.error || error?.message || "Failed to get order charge");
+      console.error("Failed to get menu order charge:", error);
+    } finally {
+      setMenuCartLoading(false);
+    }
+  };
+  const addMenuToCart = async (itemId, quantity, customizeOptions) => {
+    setMenuCartLoading(true);
+    try {
+      const body = {
+        item: itemId,
+        qty: quantity,
+        customize_option: customizeOptions || []
+      };
+      await api.api.addMenuToCart(body);
+      await fetchMenuCartDetail();
+    } catch (error) {
+      console.error("Failed to add menu item to cart:", error);
+      throw error;
+    } finally {
+      setMenuCartLoading(false);
+    }
+  };
+  const updateMenuCartItem = async (id, quantity, customizeOptions) => {
+    setMenuCartLoading(true);
+    try {
+      const body = {
+        qty: quantity,
+        customize_option: customizeOptions || []
+      };
+      await api.api.updateMenuCartItem(id, body);
+      await fetchMenuCartDetail();
+    } catch (error) {
+      console.error("Failed to update menu cart item:", error);
+      throw error;
+    } finally {
+      setMenuCartLoading(false);
+    }
+  };
+  const deleteMenuCartItem = async (id) => {
+    setMenuCartLoading(true);
+    try {
+      await api.api.deleteMenuCartItem(id);
+      await fetchMenuCartDetail();
+    } catch (error) {
+      console.error("Failed to delete menu cart item:", error);
+      throw error;
+    } finally {
+      setMenuCartLoading(false);
+    }
+  };
+  const clearMenuCart = () => {
+    setMenuCartItems([]);
+    setSession(null);
+    storage.removeItem("menuCart");
+    fetchMenuCartDetail();
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    MenuCartContext.Provider,
+    {
+      value: {
+        menuCartItems,
+        cartLength,
+        cartType,
+        session,
+        errorMessage,
+        menuCartLoading,
+        promoCodeLoading,
+        updateOrderType,
+        addMenuToCart,
+        updateMenuCartItem,
+        deleteMenuCartItem,
+        updateMenuCartPromoCode,
+        updateMenuCartAddress,
+        getMenuOrderCharge,
+        clearMenuCart
+      },
+      children: props.children
+    }
+  );
+};
+var useMenuCart = () => react.useContext(MenuCartContext);
+var ToastProvider = () => {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactToastify.ToastContainer,
+    {
+      position: "top-right",
+      autoClose: 3e3,
+      theme: "colored"
+    }
+  );
+};
+var REFERRAL_STORAGE_KEY = "referralCode";
+var ReferralCodeContext = react.createContext(null);
+function ReferralCodeProvider({
+  children,
+  referralCodeFromUrl
+}) {
+  const [referralCode, setReferralCode] = react.useState(null);
+  react.useEffect(() => {
+    if (referralCodeFromUrl) {
+      if (typeof window !== "undefined") {
+        sessionStorage.setItem(REFERRAL_STORAGE_KEY, referralCodeFromUrl);
+      }
+      setReferralCode(referralCodeFromUrl);
+    } else if (typeof window !== "undefined") {
+      setReferralCode(sessionStorage.getItem(REFERRAL_STORAGE_KEY));
+    }
+  }, [referralCodeFromUrl]);
+  return /* @__PURE__ */ jsxRuntime.jsx(ReferralCodeContext.Provider, { value: referralCode, children });
+}
+function useReferralCode() {
+  return react.useContext(ReferralCodeContext);
+}
+var LiveSupportWidgetContext = react.createContext({
+  config: null,
+  loading: true
+});
+var LiveSupportWidgetProvider = ({ children }) => {
+  const [config, setConfig] = react.useState(null);
+  const [loading, setLoading] = react.useState(true);
+  react.useEffect(() => {
+    let isMounted = true;
+    (async () => {
+      try {
+        const data = await api.api.getLiveSupportWidgetConfig();
+        if (isMounted) {
+          setConfig(data);
+        }
+      } catch (e) {
+        if (isMounted) {
+          setConfig(null);
+        }
+      } finally {
+        if (isMounted) {
+          setLoading(false);
+        }
+      }
+    })();
+    return () => {
+      isMounted = false;
+    };
+  }, []);
+  return /* @__PURE__ */ jsxRuntime.jsx(LiveSupportWidgetContext.Provider, { value: { config, loading }, children });
+};
+var useLiveSupportWidget = () => react.useContext(LiveSupportWidgetContext);
+
+exports.AuthContext = AuthContext;
+exports.AuthProvider = AuthProvider;
+exports.BaseProvider = BaseProvider;
+exports.BusinessConfigContext = BusinessConfigContext;
+exports.BusinessConfigProvider = BusinessConfigProvider;
+exports.BusinessMediaContext = BusinessMediaContext;
+exports.BusinessMediaProvider = BusinessMediaProvider;
+exports.CartContext = CartContext;
+exports.CartProvider = CartProvider;
+exports.CartWishlistRefreshContext = CartWishlistRefreshContext;
+exports.CartWishlistRefreshProvider = CartWishlistRefreshProvider;
+exports.CustomPageConfigContext = CustomPageConfigContext;
+exports.CustomPageConfigProvider = CustomPageConfigProvider;
+exports.CustomerConfigContext = CustomerConfigContext;
+exports.CustomerConfigProvider = CustomerConfigProvider;
+exports.FilterContext = FilterContext;
+exports.FilterProvider = FilterProvider;
+exports.HeaderFooterContext = HeaderFooterContext;
+exports.HeaderFooterProvider = HeaderFooterProvider;
+exports.HomeConfigContext = HomeConfigContext;
+exports.HomeConfigHeroSliderContext = HomeConfigHeroSliderContext;
+exports.HomeConfigHeroSliderProvider = HomeConfigHeroSliderProvider;
+exports.HomeConfigProvider = HomeConfigProvider;
+exports.LiveSupportWidgetProvider = LiveSupportWidgetProvider;
+exports.MenuCartContext = MenuCartContext;
+exports.MenuCartProvider = MenuCartProvider;
+exports.MenuFilterContext = MenuFilterContext;
+exports.MenuFilterProvider = MenuFilterProvider;
+exports.ModalProvider = ModalProvider;
+exports.ProductConfigContext = ProductConfigContext;
+exports.ProductConfigProvider = ProductConfigProvider;
+exports.ProductDetailContext = ProductDetailContext;
+exports.ProductDetailProvider = ProductDetailProvider;
+exports.ReferralCodeProvider = ReferralCodeProvider;
+exports.StorageContext = StorageContext;
+exports.StorageProvider = StorageProvider;
+exports.ThemeContext = ThemeContext;
+exports.ThemeEditContext = ThemeEditContext;
+exports.ThemeEditProvider = ThemeEditProvider;
+exports.ThemeProvider = ThemeProvider;
+exports.ToastProvider = ToastProvider;
+exports.WishlistContext = WishlistContext;
+exports.WishlistProvider = WishlistProvider;
+exports.useAuth = useAuth;
+exports.useBusiness = useBusiness;
+exports.useBusinessContext = useBusinessContext;
+exports.useBusinessMedia = useBusinessMedia;
+exports.useCart = useCart;
+exports.useCartWishlistRefresh = useCartWishlistRefresh;
+exports.useCustomPageConfig = useCustomPageConfig;
+exports.useCustomer = useCustomer;
+exports.useFilter = useFilter;
+exports.useHeaderFooter = useHeaderFooter;
+exports.useHomeConfig = useHomeConfig;
+exports.useHomeConfigHeroSlider = useHomeConfigHeroSlider;
+exports.useLiveSupportWidget = useLiveSupportWidget;
+exports.useMenuCart = useMenuCart;
+exports.useMenuFilter = useMenuFilter;
+exports.useModal = useModal;
+exports.useProductConfig = useProductConfig;
+exports.useProductDetail = useProductDetail;
+exports.useReferralCode = useReferralCode;
+exports.useStorage = useStorage;
+exports.useTheme = useTheme;
+exports.useThemeEdit = useThemeEdit;
+exports.useWishlist = useWishlist;
+//# sourceMappingURL=provider.cjs.map
+//# sourceMappingURL=provider.cjs.map