flowrix 1.0.1-beta.155 → 1.0.1-beta.157

package/dist/runtime/composables/Product/useProductCard.d.ts

@@ -1,13 +1,94 @@
-export default function (item: any, template?: string): {
-    ProductCard: any;
-    imagesize: (swatchImage: string) => string;
-    addToCart: (product: any, qty: number) => Promise<void>;
-    updateQuantity: (product: any, quantity: number) => Promise<void>;
+export default function (product: any): {
+    Wishlist: any;
+    SampleQuickview: any;
+    promotionsStore: import("pinia").Store<"promotions", import("../../stores/promotions.js").PromotionsState, {
+        hasPromotions: (state: {
+            promotions: any;
+            loading: boolean;
+            error: string | null;
+            fetchPromise: {
+                then: <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>;
+                catch: <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<void | TResult>;
+                finally: (onfinally?: (() => void) | null | undefined) => Promise<void>;
+                readonly [Symbol.toStringTag]: string;
+            } | null;
+        } & import("pinia").PiniaCustomStateProperties<import("../../stores/promotions.js").PromotionsState>) => boolean;
+        isLoading: (state: {
+            promotions: any;
+            loading: boolean;
+            error: string | null;
+            fetchPromise: {
+                then: <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>;
+                catch: <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<void | TResult>;
+                finally: (onfinally?: (() => void) | null | undefined) => Promise<void>;
+                readonly [Symbol.toStringTag]: string;
+            } | null;
+        } & import("pinia").PiniaCustomStateProperties<import("../../stores/promotions.js").PromotionsState>) => boolean;
+        hasError: (state: {
+            promotions: any;
+            loading: boolean;
+            error: string | null;
+            fetchPromise: {
+                then: <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>;
+                catch: <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<void | TResult>;
+                finally: (onfinally?: (() => void) | null | undefined) => Promise<void>;
+                readonly [Symbol.toStringTag]: string;
+            } | null;
+        } & import("pinia").PiniaCustomStateProperties<import("../../stores/promotions.js").PromotionsState>) => boolean;
+    }, {
+        fetchPromotions(force?: boolean): Promise<any>;
+        _doFetch(): Promise<void>;
+        refreshPromotions(): Promise<any>;
+        clearPromotions(): void;
+    }>;
+    cartStore: import("pinia").Store<"cart", import("../../stores/Cart.js").CartState, {}, {}>;
+    router: import("vue-router").Router;
+    route: import("vue-router").RouteLocationNormalizedLoadedGeneric;
+    showSampleModal: import("vue").Ref<boolean, boolean>;
+    currentSample: import("vue").Ref<any, any>;
+    showPreviewModal: import("vue").Ref<boolean, boolean>;
+    isAddingToCart: import("vue").Ref<boolean, boolean>;
+    isCustomizing: import("vue").Ref<boolean, boolean>;
+    hovered: import("vue").Ref<boolean, boolean>;
+    buttonLoading: import("vue").Ref<boolean, boolean>;
+    openWishlistModal: import("vue").Ref<boolean, boolean>;
+    wishlistModalRef: import("vue").Ref<null, null>;
+    data: import("vue").Ref<any, any>;
+    openPopup: import("vue").Ref<boolean, boolean>;
     checkInCart: import("vue").Ref<number, number>;
     productQty: import("vue").Ref<number, number>;
-    isProductInCart: (productId: string) => void;
-    promotionTag: any;
-    PopUp: any;
-    openPopup: import("vue").Ref<boolean, boolean>;
+    isAuthenticated: import("vue").ComputedRef<false>;
+    areSamplesInCart: import("vue").ComputedRef<boolean>;
+    priceData: import("vue").ComputedRef<import("../usePriceCalculation.js").PriceCalculationResult | {
+        finalPrice: any;
+        originalPrice: any;
+        totalDiscount: number;
+        hasDiscount: boolean;
+        appliedPromotions: never[];
+    }>;
+    computedPrice: import("vue").ComputedRef<any>;
+    computedPriceFloat: import("vue").ComputedRef<any>;
+    hasDiscount: import("vue").ComputedRef<boolean>;
+    originalPrice: import("vue").ComputedRef<any>;
+    openSampleModal: () => void;
+    closeSampleModal: () => void;
+    openPreviewModal: (productUrl: any) => Promise<void>;
+    closePreviewModal: () => void;
     closePopupModal: () => void;
+    openCustomizeModal: () => void;
+    imageResize: (image: string, size?: number | string) => string;
+    ensureStartsWithSlash: (str: string) => string;
+    imagesize: (swatchImage: string) => string;
+    addToCart: (prod: any, qty: number) => Promise<void>;
+    updateQuantity: (prod: any, quantity: number) => Promise<void>;
+    isProductInCart: (productId: string) => void;
+    AddTocartMidelware: (prod: any) => Promise<void>;
+    updateQuantityMidelware: (prod: any, qty: number) => Promise<void>;
+    orderSample: () => Promise<void>;
+    removeAllSamples: () => Promise<void>;
+    disableOtherSamples: (working?: boolean) => void;
+    handleOrderSample: () => void;
+    handleWishlistClick: () => void;
+    navigateToCustomize: () => void;
+    initializeProductCard: () => void;
 };

package/dist/runtime/composables/Product/useProductCard.js

@@ -1,36 +1,110 @@
-import { ref, defineAsyncComponent } from "vue";
+import { ref, defineAsyncComponent, computed } from "vue";
+import { useRouter, useRoute } from "vue-router";
 import { useCartStore } from "../../stores/Cart.js";
-export default function(item, template = "default") {
+import { useAuthStore } from "../../stores/auth.js";
+import { usePromotions } from "../../stores/promotions.js";
+import { usePriceCalculation } from "../usePriceCalculation.js";
+export default function(product) {
+  const router = useRouter();
+  const route = useRoute();
   const CartStore = useCartStore();
+  const authStore = useAuthStore();
+  const promotionsStore = usePromotions();
+  const { calculatePrice } = usePriceCalculation();
+  const Wishlist = defineAsyncComponent(() => import("~/components/WishList/modal.vue"));
+  const SampleQuickview = defineAsyncComponent(() => import("~/components/Product/SampleQuickview.vue"));
+  const showSampleModal = ref(false);
+  const currentSample = ref({});
+  const showPreviewModal = ref(false);
+  const isAddingToCart = ref(false);
+  const isCustomizing = ref(false);
+  const hovered = ref(false);
+  const buttonLoading = ref(false);
+  const openWishlistModal = ref(false);
+  const wishlistModalRef = ref(null);
+  const data = ref();
   const openPopup = ref(false);
-  const components = import.meta.glob("~/components/Product/Template*/**/*");
-  const ProductCard = defineAsyncComponent({
-    loader: async () => {
-      try {
-        const path = `/components/Product/Template-${template}/ProductCard.vue`;
-        return await components[path]?.();
-      } catch (error) {
-        const path = `/components/Product/Template-default/ProductCard.vue`;
-        return await components[path]?.();
-      }
+  const checkInCart = ref(0);
+  const productQty = ref(1);
+  const isAuthenticated = computed(() => authStore.isAuthenticated);
+  const priceData = computed(() => {
+    if (!product || !product.id || !product.rpfloat) {
+      return {
+        finalPrice: product?.pricefloat || 0,
+        originalPrice: product?.rpfloat || 0,
+        totalDiscount: 0,
+        hasDiscount: false,
+        appliedPromotions: []
+      };
     }
-  });
-  const promotionTag = defineAsyncComponent({
-    loader: async () => {
-      try {
-        return await import("@/components/Others/promotionTag.vue");
-      } catch (error) {
-        return import("@/components/Others/promotionTag.vue");
-      }
+    if (!promotionsStore.hasPromotions) {
+      return {
+        finalPrice: product.pricefloat || product.rpfloat,
+        originalPrice: product.rpfloat,
+        totalDiscount: 0,
+        hasDiscount: false,
+        appliedPromotions: []
+      };
     }
+    return calculatePrice(
+      product.id,
+      product.rpfloat,
+      promotionsStore.promotions
+    );
   });
-  const checkInCart = ref(0);
-  const productQty = ref(1);
+  const computedPrice = computed(() => {
+    const price = priceData.value.finalPrice;
+    return price.toFixed(2);
+  });
+  const computedPriceFloat = computed(() => {
+    return priceData.value.finalPrice;
+  });
+  const hasDiscount = computed(() => {
+    return priceData.value.hasDiscount;
+  });
+  const originalPrice = computed(() => {
+    return priceData.value.originalPrice.toFixed(2);
+  });
+  const openSampleModal = () => {
+    showSampleModal.value = true;
+  };
+  const closeSampleModal = () => {
+    showSampleModal.value = false;
+  };
+  const openPreviewModal = async (productUrl) => {
+    showPreviewModal.value = true;
+    const { useQuickView } = await import("../Product/useQuickView.js");
+    data.value = await useQuickView(productUrl);
+  };
+  const closePreviewModal = () => {
+    showPreviewModal.value = false;
+  };
+  const closePopupModal = () => {
+    openPopup.value = false;
+  };
+  const openCustomizeModal = () => {
+    navigateToCustomize();
+  };
+  const imageResize = (image, size = "") => {
+    if (!image) return "https://image.webp";
+    const newImage = image.replace(/.webp/gi, `${size}.webp`);
+    return newImage;
+  };
+  const ensureStartsWithSlash = (str) => {
+    return str.startsWith("/") ? str : "/" + str;
+  };
+  const imagesize = (swatchImage) => {
+    if (swatchImage) {
+      let swatchImage320 = swatchImage.replace(/.webp/gi, "320.webp");
+      return swatchImage320;
+    }
+    return swatchImage;
+  };
   const isProductInCart = (productId) => {
     if (CartStore.cart.items) {
-      var isincart = Object.values(CartStore.cart.items).filter((v) => v.slug == productId);
+      const isincart = Object.values(CartStore.cart.items).filter((v) => v.slug == productId);
       if (isincart.length > 0) {
-        productQty.value = isincart[0].qty;
+        productQty.value = isincart[0].qty || 1;
         checkInCart.value = 1;
       } else {
         productQty.value = 0;
@@ -38,51 +112,179 @@ export default function(item, template = "default") {
       }
     }
   };
-  const updateQuantity = async (product, quantity) => {
-    const SingleProduct = Object.values(CartStore.cart.items).find((item2) => item2.slug === product.slug);
-    await CartStore.updateQuantity(SingleProduct, quantity);
-    productQty.value = SingleProduct.qty;
-    isProductInCart(product.slug);
+  const areSamplesInCart = computed(() => {
+    if (CartStore.cart.items && product?.sample && Object.keys(product.sample).length > 0) {
+      return Object.values(product.sample).every(
+        (sample) => Object.values(CartStore.cart.items || {}).some(
+          (item) => item.slug === sample.slug
+        )
+      );
+    }
+    return false;
+  });
+  const disableOtherSamples = (working = false) => {
+    if (typeof document === "undefined") return;
+    const allButtons = document.querySelectorAll(".ordersample");
+    allButtons.forEach((btn) => {
+      if (working) {
+        btn.classList.add("disabled");
+      } else {
+        btn.classList.remove("disabled");
+      }
+    });
   };
-  const addToCart = async (product, qty) => {
-    await useCartStore().addToCart(product, qty);
-    if (useCartStore().addedResponse == "success") {
+  const addToCart = async (prod, qty) => {
+    await CartStore.addToCart(prod, qty);
+    if (CartStore.addedResponse == "success") {
       openPopup.value = true;
     }
-    isProductInCart(product.slug);
+    isProductInCart(prod.slug);
   };
-  const imagesize = ((swatchImage) => {
-    if (swatchImage) {
-      let swatchImage320 = swatchImage.replace(/.webp/gi, "320.webp");
-      return swatchImage320;
+  const updateQuantity = async (prod, quantity) => {
+    const SingleProduct = Object.values(CartStore.cart.items || {}).find((item) => item.slug === prod.slug);
+    if (SingleProduct) {
+      await CartStore.updateQuantity(SingleProduct, quantity);
+      productQty.value = SingleProduct.qty;
+      isProductInCart(prod.slug);
     }
-    return swatchImage;
-  });
-  const PopUp = defineAsyncComponent({
-    loader: async () => {
+  };
+  const removeAllSamples = async () => {
+    if (CartStore.cart.items && product?.sample && Object.keys(product.sample).length > 0) {
+      buttonLoading.value = true;
       try {
-        const path = `/components/Product/Template-${template}/PopUpCart.vue`;
-        return await components[path]?.();
+        for (const sample of Object.values(product.sample)) {
+          const productToRemove = Object.values(CartStore.cart.items).find(
+            (item) => item.slug === sample.slug
+          );
+          if (productToRemove) {
+            await CartStore.removeFromCart(
+              productToRemove.rowId,
+              productToRemove
+            );
+          }
+        }
       } catch (error) {
-        const path = `/components/Product/Template-default/PopUpCart.vue`;
-        return await components[path]?.();
+        console.error("Error removing samples from cart:", error);
+      } finally {
+        buttonLoading.value = false;
+      }
+    }
+  };
+  const orderSample = async () => {
+    disableOtherSamples(true);
+    if (areSamplesInCart.value) {
+      await removeAllSamples();
+      disableOtherSamples();
+    } else {
+      if (product.sample && Object.keys(product.sample).length > 0) {
+        buttonLoading.value = true;
+        try {
+          for (const sample of Object.values(product.sample)) {
+            await addToCart({ slug: sample.slug }, 1);
+          }
+        } catch (error) {
+          console.error("Error adding samples to cart:", error);
+        } finally {
+          buttonLoading.value = false;
+          disableOtherSamples();
+        }
       }
     }
-  });
-  const closePopupModal = () => {
-    openPopup.value = false;
+  };
+  const AddTocartMidelware = async (prod) => {
+    isAddingToCart.value = true;
+    try {
+      await addToCart(prod, 1);
+    } catch (error) {
+      console.error("Error adding to cart:", error);
+    } finally {
+      isAddingToCart.value = false;
+    }
+  };
+  const updateQuantityMidelware = async (prod, qty) => {
+    await updateQuantity(prod, qty);
+  };
+  const navigateToCustomize = () => {
+    isCustomizing.value = true;
+  };
+  const handleWishlistClick = () => {
+    if (!isAuthenticated.value) {
+      const returnUrl = route.fullPath;
+      router.push({
+        path: "/login",
+        query: { redirect: returnUrl }
+      });
+      return;
+    }
+    openWishlistModal.value = true;
+  };
+  const handleOrderSample = () => {
+    alert("Free sample ordered for " + product.title);
+  };
+  const initializeProductCard = () => {
+    if (product?.slug) {
+      isProductInCart(product.slug);
+    }
   };
   return {
-    ProductCard,
+    // Components
+    Wishlist,
+    SampleQuickview,
+    // Stores
+    promotionsStore,
+    cartStore: CartStore,
+    // Router
+    router,
+    route,
+    // State
+    showSampleModal,
+    currentSample,
+    showPreviewModal,
+    isAddingToCart,
+    isCustomizing,
+    hovered,
+    buttonLoading,
+    openWishlistModal,
+    wishlistModalRef,
+    data,
+    openPopup,
+    checkInCart,
+    productQty,
+    // Computed
+    isAuthenticated,
+    areSamplesInCart,
+    priceData,
+    computedPrice,
+    computedPriceFloat,
+    hasDiscount,
+    originalPrice,
+    // Modal handlers
+    openSampleModal,
+    closeSampleModal,
+    openPreviewModal,
+    closePreviewModal,
+    closePopupModal,
+    openCustomizeModal,
+    // Utilities
+    imageResize,
+    ensureStartsWithSlash,
     imagesize,
+    // Cart actions
     addToCart,
     updateQuantity,
-    checkInCart,
-    productQty,
     isProductInCart,
-    promotionTag,
-    PopUp,
-    openPopup,
-    closePopupModal
+    AddTocartMidelware,
+    updateQuantityMidelware,
+    // Sample actions
+    orderSample,
+    removeAllSamples,
+    disableOtherSamples,
+    handleOrderSample,
+    // Wishlist
+    handleWishlistClick,
+    // Other
+    navigateToCustomize,
+    // Initialize
+    initializeProductCard
   };
 }

package/dist/runtime/composables/Product/useProductComponent.js

@@ -1,9 +1,5 @@
 import { defineAsyncComponent } from "vue";
-import { useHead, useRequestEvent, useRoute } from "#imports";
-import { getRequestURL } from "h3";
-import { GTM_view_item } from "../useDataLayer.js";
-import { META_view_item } from "../useMetaLayer.js";
-import { TikTok_view_item } from "../useTikTokDatalayer.js";
+import { useHead, useRoute, useRuntimeConfig } from "#imports";
 import { useCompanyProfile } from "../../stores/useCompanyProfile.js";
 export function useProductComponent(product) {
   const route = useRoute();
@@ -26,8 +22,8 @@ export function useProductComponent(product) {
   });
   let websiteurl = "";
   if (process.server) {
-    const event = useRequestEvent();
-    websiteurl = getRequestURL(event).origin;
+    const config = useRuntimeConfig();
+    websiteurl = config.WEBSITE_URL || "";
   } else {
     websiteurl = window.location.origin;
   }
@@ -123,9 +119,6 @@ export function useProductComponent(product) {
       }
     ]
   });
-  GTM_view_item(product, product?.rrpfloat, product?.rpfloat);
-  META_view_item(product, product?.rrpfloat, product?.rpfloat);
-  TikTok_view_item(product, product?.rrpfloat, product?.rpfloat);
   return {
     Template
   };

package/dist/runtime/composables/Product/useQuickView.d.ts

@@ -5,4 +5,4 @@ export declare const useQuickView: (slug: string) => {
     execute: any;
     pending: any;
 };
-export declare const useSendQuickValues: (attributes: Record<string, any>, slug: any) => Promise<unknown>;
+export declare const useSendQuickValues: (attributes: Record<string, any>, slug: any) => Promise<any>;

package/dist/runtime/composables/Product/useService.d.ts

@@ -8,18 +8,7 @@ export declare function useService(): {
     serviceSuccess: import("vue").Ref<string, string>;
     checkingAvailability: import("vue").Ref<boolean, boolean>;
     addingToCart: import("vue").Ref<boolean, boolean>;
-    location: import("vue").ComputedRef<{
-        city?: string | undefined;
-        country_name?: string | undefined;
-        country_code?: string | undefined;
-        country_id?: number | undefined;
-        ip?: string | undefined;
-        proxy?: boolean | undefined;
-        region?: string | undefined;
-        region_short?: string | undefined;
-        region_id?: number | undefined;
-        zip_code?: string | undefined;
-    } | null>;
+    location: import("vue").ComputedRef<import("../../stores/locations.js").LocationData | null>;
     services: import("vue").ComputedRef<never[]>;
     currentService: import("vue").ComputedRef<any>;
     cart: import("vue").ComputedRef<{

package/dist/runtime/composables/Product/useService.js

@@ -1,11 +1,11 @@
 import { ref, computed, watch } from "vue";
 import { useServiceStore } from "../../stores/Services.js";
 import { useCartStore } from "../../stores/Cart.js";
-import { useIpLocation } from "../../stores/IpLocation.js";
+import { useLocationsStore } from "../../stores/locations.js";
 export function useService() {
   const serviceStore = useServiceStore();
   const cartStore = useCartStore();
-  const locationStore = useIpLocation();
+  const locationStore = useLocationsStore();
   const servicesAvailability = ref(false);
   const serviceSuccess = ref("");
   const checkingAvailability = ref(false);

package/dist/runtime/composables/index.d.ts

@@ -81,9 +81,9 @@ export { useCookieConsent } from './useCookieConsent.js';
 export { GTM_page_view, GTM_view_item, GTM_view_item_list, GTM_view_cart, GTM_add_to_cart, GTM_remove_from_cart, GTM_begin_checkout, GTM_add_shipping_info, GTM_add_payment_info, GTM_purchase, GTM_select_item_color, GTM_select_item_collection, GTM_Attribute_Content } from './useDataLayer.js';
 export { useDynamicHtmlRenderer } from './useDynamicHtmlRenderer.js';
 export { useLocation } from './useLocation.js';
-export { useLocations } from './useLocations.js';
 export { useQuotationCheckout } from './useQuotationCheckout.js';
 export { useSearch } from './useSearch.js';
 export { useSubscriptions } from './useSubscriptions.js';
 export { useWebforms } from './useWebforms.js';
 export { useApp } from './useApp.js';
+export { usePriceCalculation } from './usePriceCalculation.js';

package/dist/runtime/composables/index.js

@@ -81,9 +81,9 @@ export { useCookieConsent } from "./useCookieConsent.js";
 export { GTM_page_view, GTM_view_item, GTM_view_item_list, GTM_view_cart, GTM_add_to_cart, GTM_remove_from_cart, GTM_begin_checkout, GTM_add_shipping_info, GTM_add_payment_info, GTM_purchase, GTM_select_item_color, GTM_select_item_collection, GTM_Attribute_Content } from "./useDataLayer.js";
 export { useDynamicHtmlRenderer } from "./useDynamicHtmlRenderer.js";
 export { useLocation } from "./useLocation.js";
-export { useLocations } from "./useLocations.js";
 export { useQuotationCheckout } from "./useQuotationCheckout.js";
 export { useSearch } from "./useSearch.js";
 export { useSubscriptions } from "./useSubscriptions.js";
 export { useWebforms } from "./useWebforms.js";
 export { useApp } from "./useApp.js";
+export { usePriceCalculation } from "./usePriceCalculation.js";

package/dist/runtime/composables/useAddresses.js

@@ -1,7 +1,8 @@
 import { computed } from "vue";
 import { useAddressesStore } from "../stores/addresses.js";
 import { useAuthStore } from "../stores/auth.js";
-import { useApi } from "../utils/api.js";
+import { flowrixApi } from "../middleware/flowrix.js";
+import { useRuntimeConfig } from "#imports";
 function formatErrorMessage(message) {
   if (!message) return "An error occurred";
   if (typeof message === "string") {
@@ -20,13 +21,18 @@ function formatErrorMessage(message) {
 export function useAddresses() {
   const store = useAddressesStore();
   const { fetchProfile } = useAuthStore();
-  const { post, patch, delete: deleteRequest } = useApi();
+  const config = useRuntimeConfig();
   async function addAddress(userData) {
     store.setLoading(true);
     store.setError(null);
     try {
+      let rawCookies = "";
+      if (process.client) {
+        rawCookies = document.cookie || "";
+      }
+      const apiConfig = { ...config, cookies: rawCookies };
       userData.shipping = 1;
-      const response = await post("/mystore/customer/address/add", userData);
+      const response = await flowrixApi.post("/mystore/customer/address/add", apiConfig, { body: userData });
       if (response.status === "Success" && response.data) {
         await fetchProfile();
         return response;
@@ -48,7 +54,12 @@ export function useAddresses() {
     store.setLoading(true);
     store.setError(null);
     try {
-      const response = await patch(`/mystore/customer/address/${userData.id}/update`, userData);
+      let rawCookies = "";
+      if (process.client) {
+        rawCookies = document.cookie || "";
+      }
+      const apiConfig = { ...config, cookies: rawCookies };
+      const response = await flowrixApi.patch(`/mystore/customer/address/${userData.id}/update`, apiConfig, { body: userData });
       if (response.status === "Success" && response.data) {
         await fetchProfile();
         return response;
@@ -70,7 +81,12 @@ export function useAddresses() {
     store.setLoading(true);
     store.setError(null);
     try {
-      const response = await patch(`/mystore/customer/address/${id}/delete`, {});
+      let rawCookies = "";
+      if (process.client) {
+        rawCookies = document.cookie || "";
+      }
+      const apiConfig = { ...config, cookies: rawCookies };
+      const response = await flowrixApi.patch(`/mystore/customer/address/${id}/delete`, apiConfig, { body: {} });
       if (response.status === "Success") {
         await fetchProfile();
         return response;
@@ -92,7 +108,12 @@ export function useAddresses() {
     store.setLoading(true);
     store.setError(null);
     try {
-      const response = await post(`/mystore/customer/address/${addressId}/setshipping`, {});
+      let rawCookies = "";
+      if (process.client) {
+        rawCookies = document.cookie || "";
+      }
+      const apiConfig = { ...config, cookies: rawCookies };
+      const response = await flowrixApi.post(`/mystore/customer/address/${addressId}/setshipping`, apiConfig, { body: {} });
       if (response.status === "Success") {
         await fetchProfile();
         return response;

package/dist/runtime/composables/useApp.js

@@ -1,5 +1,4 @@
-import { useHead, useRequestEvent, useRoute } from "#imports";
-import { getRequestURL } from "h3";
+import { useHead, useRoute, useRuntimeConfig } from "#imports";
 import { useCompanyProfile } from "../stores/useCompanyProfile.js";
 export const useApp = () => {
   const route = useRoute();
@@ -21,8 +20,8 @@ export const useApp = () => {
   }
   let websiteurl = "";
   if (process.server) {
-    const event = useRequestEvent();
-    websiteurl = getRequestURL(event).origin;
+    const config = useRuntimeConfig();
+    websiteurl = config.WEBSITE_URL || "";
   } else {
     websiteurl = window.location.origin;
   }

package/dist/runtime/composables/useCards.js

@@ -1,6 +1,5 @@
 import { computed } from "vue";
 import { useCardsStore } from "../stores/cards.js";
-import { useApi } from "../utils/api.js";
 function formatErrorMessage(message) {
   if (!message) return "An error occurred";
   if (typeof message === "string") {