flowrix 1.0.1-beta.128 → 1.0.1-beta.129

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "flowrix",
   "configKey": "flowrix",
-  "version": "1.0.1-beta.128",
+  "version": "1.0.1-beta.129",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

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

@@ -1,17 +1,41 @@
-export default function (props: any): {
-    useCartStore: import("pinia").StoreDefinition<"cart", import("../../stores/Cart.js").CartState, {}, {}>;
-    ServiceStore: import("pinia").Store<"ServiceStore", {
-        services: never[];
-        availability: boolean;
-    }, {}, {
-        getAllServices(): Promise<void>;
-        checkAvailability(data: any): Promise<any>;
-    }>;
-    CurrentService: import("vue").Ref<never[], never[]>;
-    findItemBySlug: (slug: string) => any;
+interface ServiceAvailabilityPayload {
+    shipping_country: number;
+    shipping_state: number;
+    shipping_postcode: string | number;
+}
+export declare function useService(): {
+    currentService: import("vue").Ref<never[], never[]>;
     servicesAvailability: import("vue").Ref<boolean, boolean>;
-    ServiceAvailability: (data: any) => Promise<any>;
-    addToCartService: (service: any) => Promise<void>;
-    GetServiceLocations: () => Promise<void>;
-    serviceSusccess: import("vue").Ref<string, string>;
+    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>;
+    services: import("vue").ComputedRef<never[]>;
+    cart: import("vue").ComputedRef<{
+        items?: Record<string, import("../../stores/Cart.js").CartItem> | undefined;
+        totals?: Record<string, any> | undefined;
+        abndToken?: string | undefined;
+        fields?: Record<string, any> | undefined;
+    }>;
+    loading: import("vue").ComputedRef<boolean>;
+    checkAvailability: (payload: ServiceAvailabilityPayload) => Promise<any>;
+    checkAvailabilityByLocation: () => Promise<any>;
+    addToCart: (service: any) => Promise<boolean>;
+    findItemBySlug: (slug: string) => string | false;
+    isServiceInCart: (slug: string) => boolean;
+    getAllServices: () => Promise<never[]>;
+    clearSuccessMessage: () => void;
+    closeServiceModal: () => void;
 };
+export {};

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

@@ -1,64 +1,140 @@
-import { ref, watch, onMounted, computed } from "vue";
+import { ref, computed, watch } from "vue";
 import { useServiceStore } from "../../stores/Services.js";
 import { useCartStore } from "../../stores/Cart.js";
 import { useIpLocation } from "../../stores/IpLocation.js";
-export default function(props) {
-  const CurrentService = ref([]);
-  const ServiceStore = useServiceStore();
+export function useService() {
+  const serviceStore = useServiceStore();
+  const cartStore = useCartStore();
+  const locationStore = useIpLocation();
+  const currentService = ref([]);
   const servicesAvailability = ref(false);
-  const serviceSusccess = ref("");
-  const ServiceAvailability = async (data) => {
-    const response = await ServiceStore.checkAvailability(data);
-    servicesAvailability.value = response.service;
-    return response;
+  const serviceSuccess = ref("");
+  const checkingAvailability = ref(false);
+  const addingToCart = ref(false);
+  const location = computed(() => locationStore.location);
+  const services = computed(() => serviceStore.services);
+  const cart = computed(() => cartStore.cart);
+  const loading = computed(() => serviceStore.loading);
+  const checkAvailability = async (payload) => {
+    if (!payload.shipping_country || !payload.shipping_state || !payload.shipping_postcode) {
+      console.error("Invalid availability check payload:", payload);
+      return null;
+    }
+    checkingAvailability.value = true;
+    try {
+      const response = await serviceStore.checkAvailability(payload);
+      if (response?.service !== void 0) {
+        servicesAvailability.value = response.service;
+      }
+      return response;
+    } catch (error) {
+      console.error("Error checking service availability:", error);
+      return null;
+    } finally {
+      checkingAvailability.value = false;
+    }
   };
-  const ipLocation = computed(() => useIpLocation().location);
-  watch(ipLocation, async (newvalue, oldvalue) => {
-    if (useIpLocation().location != null) {
-      await ServiceAvailability({ shipping_country: useIpLocation().location.country_id, shipping_state: useIpLocation().location.region_id, shipping_postcode: useIpLocation().location.zip_code });
+  const checkAvailabilityByLocation = async () => {
+    if (!location.value) {
+      console.warn("No location available for availability check");
+      return null;
     }
-  });
-  const addToCartService = async (service) => {
-    await useCartStore().addToCart("", 1, "", "", service);
-    if (useCartStore().addedResponse == "success") {
-      serviceSusccess.value = "Services Added to cart.";
+    const payload = {
+      shipping_country: location.value.country_id,
+      shipping_state: location.value.region_id,
+      shipping_postcode: location.value.zip_code
+    };
+    return await checkAvailability(payload);
+  };
+  const addToCart = async (service) => {
+    if (!service) {
+      console.error("No service provided");
+      return false;
     }
-    var modalEl = document.querySelector(".serviceModelSuccess");
-    var serviceModelsuccess = bootstrap.Modal.getInstance(modalEl);
-    if (serviceModelsuccess) {
-      serviceModelsuccess.hide();
+    addingToCart.value = true;
+    serviceSuccess.value = "";
+    try {
+      await cartStore.addToCart("", 1, "", "", service);
+      if (cartStore.addedResponse === "success") {
+        serviceSuccess.value = "Service added to cart successfully.";
+        closeServiceModal();
+        return true;
+      }
+      return false;
+    } catch (error) {
+      console.error("Error adding service to cart:", error);
+      return false;
+    } finally {
+      addingToCart.value = false;
     }
   };
   const findItemBySlug = (slug) => {
-    if (Object.values(useCartStore().cart).length > 0) {
-      const entries = Object.values(useCartStore().cart.items);
-      let item = entries.find((entry) => entry.slug === slug);
-      if (item) {
-        return item.rowId;
-      } else {
-        return false;
+    if (!cart.value?.items || Object.keys(cart.value.items).length === 0) {
+      return false;
+    }
+    const entries = Object.values(cart.value.items);
+    const item = entries.find((entry) => entry.slug === slug);
+    return item ? item.rowId : false;
+  };
+  const isServiceInCart = (slug) => {
+    return findItemBySlug(slug) !== false;
+  };
+  const closeServiceModal = () => {
+    const modalEl = document.querySelector(".serviceModelSuccess");
+    if (modalEl && typeof bootstrap !== "undefined") {
+      const serviceModal = bootstrap.Modal.getInstance(modalEl);
+      if (serviceModal) {
+        serviceModal.hide();
       }
     }
-    return false;
   };
-  onMounted(async () => {
-    await ServiceStore.getAllServices();
-    findItemBySlug("check-measure");
-    if (useIpLocation().location != null) {
-      ServiceAvailability({ shipping_country: useIpLocation().location.country_id, shipping_state: useIpLocation().location.region_id, shipping_postcode: useIpLocation().location.zip_code });
+  const getAllServices = async () => {
+    try {
+      await serviceStore.getAllServices();
+      return services.value;
+    } catch (error) {
+      console.error("Error fetching services:", error);
+      return [];
     }
-  });
-  const GetServiceLocations = async () => {
   };
+  const clearSuccessMessage = () => {
+    serviceSuccess.value = "";
+  };
+  const autoClearSuccess = () => {
+    if (serviceSuccess.value) {
+      setTimeout(() => {
+        clearSuccessMessage();
+      }, 5e3);
+    }
+  };
+  watch(location, async (newLocation) => {
+    if (newLocation) {
+      await checkAvailabilityByLocation();
+    }
+  });
+  watch(() => serviceSuccess.value, () => {
+    autoClearSuccess();
+  });
   return {
-    useCartStore,
-    ServiceStore,
-    CurrentService,
-    findItemBySlug,
+    // State
+    currentService,
     servicesAvailability,
-    ServiceAvailability,
-    addToCartService,
-    GetServiceLocations,
-    serviceSusccess
+    serviceSuccess,
+    checkingAvailability,
+    addingToCart,
+    // Computed
+    location,
+    services,
+    cart,
+    loading,
+    // Methods
+    checkAvailability,
+    checkAvailabilityByLocation,
+    addToCart,
+    findItemBySlug,
+    isServiceInCart,
+    getAllServices,
+    clearSuccessMessage,
+    closeServiceModal
   };
 }

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

@@ -1,13 +1,63 @@
-export interface LocationData {
+interface LocationInputs {
     country: string;
-    countryCode?: string;
-    state?: string;
+    country_id: string | number;
+    zip_code: string | number;
+    region: string;
+    region_id: string | number | null;
+}
+interface LocationData {
     city?: string;
+    country_name?: string;
+    country_code?: string;
+    country_id?: number;
+    ip?: string;
+    proxy?: boolean;
+    region?: string;
+    region_short?: string;
+    region_id?: number;
+    zip_code?: string;
 }
-export declare const useLocation: () => {
-    location: Readonly<import("vue").Ref<any, any>>;
-    shippingCountry: Readonly<import("vue").Ref<any, any>>;
-    updateLocation: (newLocation: Partial<LocationData>) => void;
-    updateCountry: (country: string, countryCode?: string) => void;
-    resetLocation: () => void;
+export declare function useLocation(): {
+    states: import("vue").Ref<never[], never[]>;
+    manualLocationHeading: import("vue").Ref<string | null, string | null>;
+    locationInputs: import("vue").Ref<{
+        country: string;
+        country_id: string | number;
+        zip_code: string | number;
+        region: string;
+        region_id: string | number | null;
+    }, LocationInputs | {
+        country: string;
+        country_id: string | number;
+        zip_code: string | number;
+        region: string;
+        region_id: string | number | null;
+    }>;
+    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>;
+    countries: import("vue").ComputedRef<any>;
+    loading: import("vue").ComputedRef<boolean>;
+    companyCountryId: import("vue").ComputedRef<any>;
+    getStateShort: (stateName: string) => string;
+    getStates: (countryId: number | string) => any;
+    changeStates: (selectedCountry: string | number) => void;
+    changeLocation: (data?: Partial<LocationInputs>) => Promise<void>;
+    updateLocationData: (data?: Partial<LocationInputs>) => Promise<void>;
+    getLocation: () => Promise<void>;
+    checkCurrentLocation: () => void;
+    initLocationInputs: () => void;
+    loadLocation: () => LocationData | null;
+    checkLocationPermission: () => Promise<string>;
+    initializeCountriesAndStates: () => Promise<void>;
 };
+export {};

package/dist/runtime/composables/useLocation.js

@@ -1,32 +1,357 @@
-import { computed, readonly } from "vue";
-import { useCookie } from "#imports";
-export const useLocation = () => {
-  const locationCookie = useCookie("location", {
-    default: () => ({ country: "US" }),
-    // Default country
-    maxAge: 60 * 60 * 24 * 365,
-    // 1 year
-    sameSite: "lax"
+import { ref, computed, watch, nextTick } from "vue";
+import { useIpLocation } from "../stores/IpLocation.js";
+import { useCountriesStore } from "../stores/countries.js";
+import { useCompanyProfile } from "../stores/useCompanyProfile.js";
+import { useCheckoutStore } from "../stores/Checkout.js";
+export function useLocation() {
+  const locationStore = useIpLocation();
+  const countriesStore = useCountriesStore();
+  const companyProfileStore = useCompanyProfile();
+  const checkoutStore = useCheckoutStore();
+  const states = ref([]);
+  const manualLocationHeading = ref(null);
+  const locationInputs = ref({
+    country: "Australia",
+    country_id: 14,
+    zip_code: 3370,
+    region: "",
+    region_id: null
   });
-  const location = computed(() => locationCookie.value);
-  const updateLocation = (newLocation) => {
-    locationCookie.value = {
-      ...locationCookie.value,
-      ...newLocation
+  const location = computed(() => locationStore.location);
+  const countries = computed(() => {
+    const storeCountries = countriesStore.countries;
+    if (Array.isArray(storeCountries)) {
+      return storeCountries;
+    } else if (storeCountries?.data && Array.isArray(storeCountries.data)) {
+      return storeCountries.data;
+    }
+    return [];
+  });
+  const loading = computed(() => locationStore.loading);
+  const profile = computed(() => companyProfileStore.profile);
+  const companyCountryId = computed(() => profile.value?.country_id || 14);
+  const stateShortCodes = {
+    "New South Wales": "NSW",
+    "Victoria": "VIC",
+    "Queensland": "QLD",
+    "South Australia": "SA",
+    "Western Australia": "WA",
+    "Tasmania": "TAS",
+    "Northern Territory": "NT",
+    "Australian Capital Territory": "ACT"
+  };
+  const getStateShort = (stateName) => {
+    return stateShortCodes[stateName] || stateName;
+  };
+  const getStates = (countryId) => {
+    if (!countries.value || countries.value.length === 0) {
+      console.warn("No countries available");
+      return [];
+    }
+    const activeCountry = countries.value.find(
+      (country) => country.id == countryId || country.name == countryId
+    );
+    if (activeCountry && activeCountry.states) {
+      states.value = activeCountry.states;
+      return activeCountry.states;
+    } else {
+      states.value = [];
+      console.warn("No states found for country:", countryId);
+      return [];
+    }
+  };
+  const changeStates = (selectedCountry) => {
+    const country = countries.value?.find(
+      (c) => c.name === selectedCountry || c.id === selectedCountry
+    );
+    if (country) {
+      states.value = country.states || [];
+      locationInputs.value.country_id = country.id;
+      locationInputs.value.region = "";
+      locationInputs.value.region_id = null;
+      if (window.locationcountry === country.name && window.locationstate) {
+        locationInputs.value.region = window.locationstate;
+        const state = country.states?.find((s) => s.name === window.locationstate);
+        if (state) {
+          locationInputs.value.region_id = state.id;
+        }
+      }
+    } else {
+      console.warn("Country not found:", selectedCountry);
+    }
+  };
+  const updateLocationData = async (data = {}) => {
+    try {
+      const currentLocation = location.value;
+      const updateData = {
+        region: data.region || currentLocation?.region || "",
+        region_id: data.region_id || currentLocation?.region_id || null,
+        zip_code: data.zip_code || currentLocation?.zip_code || "",
+        country: data.country || currentLocation?.country_name || "Australia",
+        country_id: data.country_id || currentLocation?.country_id || companyCountryId.value
+      };
+      const country = countries.value?.find(
+        (c) => c.name === updateData.country || c.id === updateData.country_id
+      );
+      if (!country) {
+        console.error("Country not found:", updateData.country);
+        return;
+      }
+      const state = country.states?.find(
+        (s) => s.name === updateData.region || s.id === updateData.region_id
+      );
+      if (!state) {
+        console.error("State not found:", updateData.region);
+        return;
+      }
+      const newLocation = {
+        zip_code: updateData.zip_code,
+        region: state.name,
+        region_short: getStateShort(state.name),
+        region_id: state.id,
+        country_name: country.name,
+        country_id: country.id
+      };
+      locationStore.location = newLocation;
+      checkoutStore.saveToCheckoutSession(newLocation, "changelocation");
+    } catch (error) {
+      console.error("Error updating location:", error);
+    }
+  };
+  const changeLocation = async (data) => {
+    if (data && Object.keys(data).length > 0) {
+      await updateLocationData(data);
+    }
+  };
+  const checkLocationPermission = async () => {
+    try {
+      const permissionStatus = await navigator.permissions.query({
+        name: "geolocation"
+      });
+      return permissionStatus.state;
+    } catch (error) {
+      console.error("Permission check failed:", error);
+      return "error";
+    }
+  };
+  const getBrowserLocation = async () => {
+    return new Promise((resolve, reject) => {
+      if (!navigator.geolocation) {
+        reject(new Error("Geolocation not supported"));
+        return;
+      }
+      navigator.geolocation.getCurrentPosition(
+        async (position) => {
+          try {
+            await processGeolocation(position);
+            resolve();
+          } catch (error) {
+            reject(error);
+          }
+        },
+        async (error) => {
+          console.error("Geolocation error:", error);
+          if (profile.value?.iplocation && !location.value) {
+            await locationStore.getLocation();
+          } else {
+            manualLocationHeading.value = "We need your location to check service availability in your area. You can add your location manually.";
+            const changeLocationBtn = document.querySelector(".change_location");
+            if (changeLocationBtn) {
+              changeLocationBtn.click();
+            }
+          }
+          reject(error);
+        }
+      );
+    });
+  };
+  const processGeolocation = async (position) => {
+    const lat = position.coords.latitude;
+    const lng = position.coords.longitude;
+    const apiKey = window.GeocodingAPI;
+    if (!apiKey) {
+      throw new Error("Geocoding API key not found");
+    }
+    try {
+      const response = await fetch(
+        `https://maps.googleapis.com/maps/api/geocode/json?latlng=${lat},${lng}&key=${apiKey}`
+      );
+      const data = await response.json();
+      if (data.status !== "OK") {
+        throw new Error("Geocoding failed");
+      }
+      const locationData = extractLocationData(data.results);
+      const country = countries.value?.find((c) => c.name === locationData.country);
+      if (country) {
+        const state = country.states?.find((s) => s.name === locationData.state);
+        locationStore.location = {
+          city: locationData.city,
+          country_name: country.name,
+          country_code: locationData.country_code,
+          country_id: country.id,
+          ip: "",
+          proxy: false,
+          region: locationData.state,
+          region_short: locationData.state_short,
+          region_id: state?.id,
+          zip_code: locationData.postal_code
+        };
+      }
+    } catch (error) {
+      console.error("Geocoding error:", error);
+      if (profile.value?.iplocation && !location.value) {
+        await locationStore.getLocation();
+      }
+    }
+  };
+  const extractLocationData = (results) => {
+    const data = {
+      city: "N/A",
+      country: "N/A",
+      country_code: "N/A",
+      state: "N/A",
+      state_short: "N/A",
+      postal_code: "N/A"
     };
+    for (const result of results) {
+      for (const component of result.address_components) {
+        if (component.types.includes("administrative_area_level_2")) {
+          data.city = component.long_name;
+        }
+        if (component.types.includes("country")) {
+          data.country = component.long_name;
+          data.country_code = component.short_name;
+        }
+        if (component.types.includes("administrative_area_level_1")) {
+          data.state = component.long_name;
+          data.state_short = component.short_name;
+        }
+        if (component.types.includes("postal_code")) {
+          data.postal_code = component.long_name;
+        }
+      }
+    }
+    return data;
+  };
+  const initializeCountriesAndStates = async () => {
+    try {
+      if (!countries.value || countries.value.length === 0) {
+        const fetchedCountries = await countriesStore.getCountries();
+      }
+      await nextTick();
+      if (countries.value && countries.value.length > 0) {
+        const statesResult = getStates(companyCountryId.value);
+        const defaultCountry = countries.value.find((c) => c.id === companyCountryId.value);
+        if (defaultCountry) {
+          locationInputs.value.country = defaultCountry.name;
+          locationInputs.value.country_id = defaultCountry.id;
+        }
+      }
+    } catch (error) {
+      console.error("Error initializing countries and states:", error);
+    }
+  };
+  const getLocation = async () => {
+    try {
+      await initializeCountriesAndStates();
+      if (location.value) {
+        initLocationInputs();
+        return;
+      }
+      if (profile.value) {
+        profile.value.iplocation = true;
+      }
+      if (window.GeocodingAPI && !location.value) {
+        try {
+          await getBrowserLocation();
+          return;
+        } catch (error) {
+          console.log("Browser location failed, falling back to IP location");
+        }
+      }
+      if (profile.value?.iplocation && !location.value) {
+        await locationStore.getLocation();
+      }
+      if (location.value) {
+        initLocationInputs();
+      }
+    } catch (error) {
+      console.error("Error getting location:", error);
+    }
   };
-  const updateCountry = (country, countryCode) => {
-    updateLocation({ country, countryCode });
+  const checkCurrentLocation = () => {
+    if (location.value?.region) {
+      locationInputs.value.region = location.value.region;
+      locationInputs.value.region_id = location.value.region_id || null;
+      if (location.value.country_id) {
+        getStates(location.value.country_id);
+      }
+    }
   };
-  const shippingCountry = computed(() => location.value.country);
-  const resetLocation = () => {
-    locationCookie.value = { country: "US" };
+  const initLocationInputs = () => {
+    if (location.value) {
+      locationInputs.value = {
+        country: location.value.country_name || "Australia",
+        country_id: location.value.country_id || companyCountryId.value,
+        zip_code: location.value.zip_code || 3370,
+        region: location.value.region || "",
+        region_id: location.value.region_id || null
+      };
+      if (location.value.country_id) {
+        getStates(location.value.country_id);
+      }
+    }
   };
+  const loadLocation = () => {
+    const stored = localStorage.getItem("IpLocation");
+    if (stored) {
+      try {
+        const parsed = JSON.parse(stored);
+        return parsed.location || null;
+      } catch (error) {
+        console.error("Invalid IpLocation data:", error);
+        return null;
+      }
+    }
+    return null;
+  };
+  watch(location, (newLocation) => {
+    if (newLocation) {
+      initLocationInputs();
+    }
+  });
+  watch(countries, (newCountries) => {
+    if (newCountries && newCountries.length > 0) {
+      getStates(companyCountryId.value);
+      if (locationInputs.value.country_id) {
+        const country = newCountries.find((c) => c.id === locationInputs.value.country_id);
+        if (country) {
+          locationInputs.value.country = country.name;
+        }
+      }
+    }
+  });
   return {
-    location: readonly(location),
-    shippingCountry: readonly(shippingCountry),
-    updateLocation,
-    updateCountry,
-    resetLocation
+    // State
+    states,
+    manualLocationHeading,
+    locationInputs,
+    // Computed
+    location,
+    countries,
+    loading,
+    companyCountryId,
+    // Methods
+    getStateShort,
+    getStates,
+    changeStates,
+    changeLocation,
+    updateLocationData,
+    getLocation,
+    checkCurrentLocation,
+    initLocationInputs,
+    loadLocation,
+    checkLocationPermission,
+    initializeCountriesAndStates
   };
-};
+}

package/dist/runtime/stores/Checkout.js

@@ -78,7 +78,11 @@ export const useCheckoutStore = defineStore("checkout", {
         if (useCartStore().coupon?.length > 0) {
           formData.vouchercodes = useCartStore().coupon;
         }
-        formData.cart = useCartStore().cart.items;
+        if (useCartStore().cart.items != void 0 && Object.keys(useCartStore().cart.items).length > 0) {
+          formData.cart = useCartStore().cart.items;
+        } else {
+          delete formData.cart;
+        }
         formData.abndToken = useCartStore().cart.abndToken;
         const apiUrl = `checkout/configs`;
         const config = useRuntimeConfig();

package/dist/runtime/stores/IpLocation.d.ts

@@ -1,4 +1,4 @@
-interface LocationData {
+export interface LocationData {
     city?: string;
     country_name?: string;
     country_code?: string;
@@ -10,9 +10,100 @@ interface LocationData {
     region_id?: number;
     zip_code?: string;
 }
+export interface LocationResponse {
+    status: string;
+    message?: string;
+    data: LocationData | null;
+}
 export declare const useIpLocation: import("pinia").StoreDefinition<"IpLocation", {
     location: LocationData | null;
-}, {}, {
-    getLocation(): Promise<void>;
+    loading: boolean;
+    error: string | null;
+}, {
+    hasLocation: (state: {
+        location: {
+            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;
+        loading: boolean;
+        error: string | null;
+    } & import("pinia").PiniaCustomStateProperties<{
+        location: LocationData | null;
+        loading: boolean;
+        error: string | null;
+    }>) => boolean;
+    isLoading: (state: {
+        location: {
+            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;
+        loading: boolean;
+        error: string | null;
+    } & import("pinia").PiniaCustomStateProperties<{
+        location: LocationData | null;
+        loading: boolean;
+        error: string | null;
+    }>) => boolean;
+    locationString: (state: {
+        location: {
+            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;
+        loading: boolean;
+        error: string | null;
+    } & import("pinia").PiniaCustomStateProperties<{
+        location: LocationData | null;
+        loading: boolean;
+        error: string | null;
+    }>) => string;
+    fullAddress: (state: {
+        location: {
+            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;
+        loading: boolean;
+        error: string | null;
+    } & import("pinia").PiniaCustomStateProperties<{
+        location: LocationData | null;
+        loading: boolean;
+        error: string | null;
+    }>) => string;
+}, {
+    getLocation(): Promise<LocationData | null>;
+    setLocation(locationData: LocationData): void;
+    updateLocation(partialData: Partial<LocationData>): void;
+    clearLocation(): void;
+    clearError(): void;
 }>;
-export {};

package/dist/runtime/stores/IpLocation.js

@@ -1,29 +1,107 @@
 import { defineStore } from "pinia";
+import { flowrixApi } from "../middleware/flowrix.js";
+import { useRuntimeConfig } from "#imports";
+function formatErrorMessage(message) {
+  if (Array.isArray(message)) {
+    return message.join(", ");
+  }
+  return message;
+}
 export const useIpLocation = defineStore("IpLocation", {
   state: () => ({
-    location: null
+    location: null,
+    loading: false,
+    error: null
   }),
+  getters: {
+    hasLocation: (state) => state.location !== null,
+    isLoading: (state) => state.loading,
+    locationString: (state) => {
+      if (!state.location) return "";
+      const parts = [
+        state.location.city,
+        state.location.region_short || state.location.region,
+        state.location.zip_code
+      ].filter(Boolean);
+      return parts.join(", ");
+    },
+    fullAddress: (state) => {
+      if (!state.location) return "";
+      const parts = [
+        state.location.city,
+        state.location.region,
+        state.location.zip_code,
+        state.location.country_name
+      ].filter(Boolean);
+      return parts.join(", ");
+    }
+  },
   actions: {
     async getLocation() {
+      if (this.loading || this.location !== null) {
+        console.log("Location already loaded or loading:", this.location);
+        return this.location;
+      }
+      this.loading = true;
+      this.error = null;
       try {
-        if (this.location == null) {
-          const response = await $fetch(`/api/location`, {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json"
-            }
-          });
-          if (response.status == "Success" && response.data != null) {
-            this.location = response.data;
-          } else {
-            this.location = null;
-          }
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = "location";
+        const response = await flowrixApi.post(apiUrl, apiConfig);
+        if (response.status === "Success" && response.data !== null) {
+          this.location = response.data;
+          console.log("Location loaded:", this.location);
+          return response.data;
+        } else {
+          const errorMessage = response.message ? formatErrorMessage(response.message) : "Failed to fetch location";
+          this.error = errorMessage;
+          console.error("Failed to fetch location:", errorMessage);
+          this.location = null;
+          return null;
         }
       } catch (error) {
-        console.error("Error fetching data:", error);
+        console.error("Error fetching location:", error);
+        this.error = error.message || "Unknown error occurred";
         this.location = null;
+        return null;
+      } finally {
+        this.loading = false;
+      }
+    },
+    setLocation(locationData) {
+      this.location = locationData;
+      this.error = null;
+      console.log("Location set manually:", this.location);
+    },
+    updateLocation(partialData) {
+      if (this.location) {
+        this.location = { ...this.location, ...partialData };
+        console.log("Location updated:", this.location);
+      } else {
+        console.warn("Cannot update location: no location data exists");
       }
+    },
+    clearLocation() {
+      this.location = null;
+      this.error = null;
+      this.loading = false;
+      console.log("Location cleared");
+    },
+    clearError() {
+      this.error = null;
     }
   },
-  persist: true
+  persist: {
+    key: "IpLocation",
+    storage: typeof window !== "undefined" ? localStorage : void 0,
+    paths: ["location"]
+  }
 });

package/dist/runtime/stores/Services.d.ts

@@ -1,6 +1,8 @@
 export declare const useServiceStore: import("pinia").StoreDefinition<"ServiceStore", {
     services: never[];
     availability: boolean;
+    loading: boolean;
+    error: string | null;
 }, {}, {
     getAllServices(): Promise<void>;
     checkAvailability(data: any): Promise<any>;

package/dist/runtime/stores/Services.js

@@ -1,9 +1,13 @@
 import { defineStore } from "pinia";
+import { flowrixApi } from "../middleware/flowrix.js";
+import { useRuntimeConfig } from "#imports";
 import { useCheckoutStore } from "./Checkout.js";
 export const useServiceStore = defineStore("ServiceStore", {
   state: () => ({
     services: [],
-    availability: false
+    availability: false,
+    loading: false,
+    error: null
   }),
   actions: {
     async getAllServices() {
@@ -25,24 +29,36 @@ export const useServiceStore = defineStore("ServiceStore", {
       }
     },
     async checkAvailability(data) {
+      this.loading = true;
+      this.error = null;
       try {
-        const apiUrl = `/api/services/availability`;
-        const response = await $fetch(apiUrl, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          },
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = "services/availability";
+        const response = await flowrixApi.post(apiUrl, apiConfig, {
           body: data
         });
-        if (response.status == "Success") {
+        if (response.status === "Success") {
           this.availability = response.data.service;
           useCheckoutStore().saveToCheckoutSession(data);
           return response.data;
         } else {
-          this.data = null;
+          this.error = response.message || "Failed to check availability";
+          return null;
         }
       } catch (error) {
-        console.error("Error fetching data:", error);
+        console.error("Error checking availability:", error);
+        this.error = error.message || "Failed to check availability";
+        return null;
+      } finally {
+        this.loading = false;
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowrix",
-  "version": "1.0.1-beta.128",
+  "version": "1.0.1-beta.129",
   "description": "Plug-and-play Nuxt eCommerce cart powered by FLOWRiX. Subscription required.",
   "license": "MIT",
   "type": "module",