flowrix 1.0.0

package/dist/runtime/composables/useAddresses.js

@@ -0,0 +1,126 @@
+import { computed } from "vue";
+import { useAddressesStore } from "../stores/addresses.js";
+import { useAuth } from "./useAuth.js";
+import { useApi } from "../utils/api.js";
+function formatErrorMessage(message) {
+  if (!message) return "An error occurred";
+  if (typeof message === "string") {
+    return message;
+  }
+  const errorMessages = [];
+  for (const [field, errors] of Object.entries(message)) {
+    if (Array.isArray(errors)) {
+      errorMessages.push(...errors);
+    } else {
+      errorMessages.push(String(errors));
+    }
+  }
+  return errorMessages.join(", ");
+}
+export function useAddresses() {
+  const store = useAddressesStore();
+  const { fetchProfile } = useAuth();
+  const { post, patch, delete: deleteRequest } = useApi();
+  async function addAddress(userData) {
+    store.setLoading(true);
+    store.setError(null);
+    try {
+      userData.shipping = 1;
+      const response = await post("/customer/address/add", userData);
+      if (response.status === "Success" && response.data) {
+        await fetchProfile();
+        return response;
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        store.setError(errorMessage);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      console.error("Add address error:", error);
+      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to add address";
+      store.setError(errorMessage);
+      throw new Error(errorMessage);
+    } finally {
+      store.setLoading(false);
+    }
+  }
+  async function updateAddress(userData) {
+    store.setLoading(true);
+    store.setError(null);
+    try {
+      const response = await patch(`/customer/address/${userData.id}/update`, userData);
+      if (response.status === "Success" && response.data) {
+        await fetchProfile();
+        return response;
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        store.setError(errorMessage);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      console.error("Update address error:", error);
+      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to update address";
+      store.setError(errorMessage);
+      throw new Error(errorMessage);
+    } finally {
+      store.setLoading(false);
+    }
+  }
+  async function deleteAddress(id) {
+    store.setLoading(true);
+    store.setError(null);
+    try {
+      const response = await patch(`/customer/address/${id}/delete`, {});
+      if (response.status === "Success") {
+        await fetchProfile();
+        return response;
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        store.setError(errorMessage);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      console.error("Delete address error:", error);
+      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to delete address";
+      store.setError(errorMessage);
+      throw new Error(errorMessage);
+    } finally {
+      store.setLoading(false);
+    }
+  }
+  async function setDefaultAddress(addressId) {
+    store.setLoading(true);
+    store.setError(null);
+    try {
+      const response = await post(`/customer/address/${addressId}/setshipping`, {});
+      if (response.status === "Success") {
+        await fetchProfile();
+        return response;
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        store.setError(errorMessage);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      console.error("Set default address error:", error);
+      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to set default address";
+      store.setError(errorMessage);
+      throw new Error(errorMessage);
+    } finally {
+      store.setLoading(false);
+    }
+  }
+  async function syncAddressesFromUser(userAddresses) {
+    store.setAddresses(userAddresses);
+  }
+  return {
+    addAddress,
+    updateAddress,
+    deleteAddress,
+    setDefaultAddress,
+    syncAddressesFromUser,
+    addresses: computed(() => store.addresses),
+    loading: computed(() => store.loading),
+    error: computed(() => store.error)
+  };
+}

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

@@ -0,0 +1,45 @@
+import { type User } from '../stores/auth.js';
+export interface AuthCredentials {
+    email: string;
+    password: string;
+}
+export interface ChangePasswordData {
+    current_password: string;
+    password: string;
+    password_confirmation: string;
+}
+export interface AuthResponse {
+    status: string;
+    message: string | Record<string, string[]> | null;
+    data: {
+        access_token: string;
+        token_type: string;
+        expires_in: number | null;
+        user: User;
+    } | null;
+}
+export declare function useAuth(): {
+    login: (credentials: AuthCredentials) => Promise<AuthResponse>;
+    register: (data: AuthCredentials & {
+        name?: string;
+    }) => Promise<AuthResponse>;
+    verifyEmail: (email: string) => Promise<AuthResponse>;
+    verifyToken: (email: string, token: string) => Promise<AuthResponse>;
+    resetPassword: (token: string, password: string, password_confirmation: string) => Promise<AuthResponse>;
+    logout: () => Promise<void>;
+    fetchProfile: () => Promise<User | null>;
+    updateProfile: (userData: any) => Promise<{
+        status: string;
+        message: string;
+    }>;
+    changePassword: (passwordData: ChangePasswordData) => Promise<{
+        status: string;
+        message: string;
+    }>;
+    initializeAuth: () => void;
+    formatErrorMessage: (message: string | Record<string, string[]> | null) => string;
+    user: import("vue").ComputedRef<User | null>;
+    token: import("vue").ComputedRef<string | null>;
+    isAuthenticated: import("vue").ComputedRef<boolean>;
+    isHydrated: import("vue").ComputedRef<boolean>;
+};

package/dist/runtime/composables/useAuth.js

@@ -0,0 +1,180 @@
+import { computed } from "vue";
+import { useAuthStore } from "../stores/auth.js";
+import { useApi } from "../utils/api.js";
+export function useAuth() {
+  const authStore = useAuthStore();
+  const { post, get } = useApi();
+  function formatErrorMessage(message) {
+    if (!message) return "";
+    if (typeof message === "string") {
+      return message;
+    }
+    const errorMessages = [];
+    for (const [, errors] of Object.entries(message)) {
+      if (Array.isArray(errors)) {
+        errorMessages.push(...errors);
+      } else {
+        errorMessages.push(String(errors));
+      }
+    }
+    return errorMessages.join(", ");
+  }
+  async function login(credentials) {
+    try {
+      const response = await post("/login", credentials);
+      if (response.status === "Success" && response.data?.access_token && response.data?.user) {
+        authStore.setAuth({
+          user: response.data.user,
+          token: response.data.access_token
+        });
+      }
+      return response;
+    } catch (error) {
+      console.error("Login error:", error);
+      const message = error.data ? formatErrorMessage(error.data.message) : error.message || "Login failed";
+      return {
+        status: "Error",
+        message,
+        data: null
+      };
+    }
+  }
+  async function register(data) {
+    try {
+      const response = await post("/customer/create", data);
+      return response;
+    } catch (error) {
+      console.error("Registration error:", error);
+      const message = error.data ? formatErrorMessage(error.data.message) : error.message || "Registration failed";
+      return {
+        status: "Error",
+        message,
+        data: null
+      };
+    }
+  }
+  async function verifyEmail(email) {
+    try {
+      const response = await post("/verify-email", { email });
+      return response;
+    } catch (error) {
+      console.error("Verify email error:", error);
+      const message = error.data ? formatErrorMessage(error.data.message) : error.message || "email verification failed";
+      return {
+        status: "Error",
+        message,
+        data: null
+      };
+    }
+  }
+  async function verifyToken(email, token) {
+    try {
+      const response = await post("/verify-token", { email, token });
+      return response;
+    } catch (error) {
+      console.error("Verify token error:", error);
+      const message = error.data ? formatErrorMessage(error.data.message) : error.message || "Token verification failed";
+      return {
+        status: "Error",
+        message,
+        data: null
+      };
+    }
+  }
+  async function resetPassword(token, password, password_confirmation) {
+    try {
+      const response = await post("/reset-password", {
+        token,
+        password,
+        password_confirmation
+      });
+      return response;
+    } catch (error) {
+      console.error("Reset password error:", error);
+      const message = error.data ? formatErrorMessage(error.data.message) : error.message || "Password reset failed";
+      return {
+        status: "Error",
+        message,
+        data: null
+      };
+    }
+  }
+  async function logout() {
+    try {
+      await post("/customer/logout", {});
+    } catch (error) {
+      console.error("Logout API failed:", error);
+    } finally {
+      authStore.logout();
+    }
+  }
+  async function fetchProfile() {
+    try {
+      const response = await get("/customer/profile");
+      if (response.status === "Success" && response.data) {
+        authStore.user = response.data;
+        if (import.meta.client) {
+          localStorage.setItem("auth_user", JSON.stringify(response.data));
+        }
+        return response.data;
+      }
+      return null;
+    } catch (error) {
+      console.error("Fetch profile failed:", error);
+      return null;
+    }
+  }
+  async function updateProfile(userData) {
+    try {
+      const response = await post("/customer/profile/update", userData);
+      if (response.status === "Success") {
+        await fetchProfile();
+        return { status: response.status, message: response.message || "Profile Updated Successfully" };
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      console.error("Update profile error:", error);
+      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to update profile";
+      throw new Error(errorMessage);
+    }
+  }
+  async function changePassword(passwordData) {
+    try {
+      const response = await post("/customer/change-password", passwordData);
+      if (response.status === "Success") {
+        return { status: "Success", message: "Password updated successfully" };
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      console.error("Change password error:", error);
+      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to change password";
+      throw new Error(errorMessage);
+    }
+  }
+  const initializeAuth = () => {
+    if (import.meta.client && !authStore.isHydrated) {
+      authStore.loadAuth();
+    }
+  };
+  return {
+    login,
+    register,
+    verifyEmail,
+    verifyToken,
+    resetPassword,
+    logout,
+    fetchProfile,
+    updateProfile,
+    changePassword,
+    initializeAuth,
+    formatErrorMessage,
+    user: computed(() => authStore.getUser),
+    token: computed(() => authStore.getToken),
+    isAuthenticated: computed(() => authStore.isLoggedIn),
+    isHydrated: computed(() => authStore.isHydrated)
+  };
+}

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

@@ -0,0 +1,19 @@
+import { type Card } from '../stores/cards.js';
+export interface ApiResponse<T> {
+    status: string;
+    message: string | Record<string, string[]> | null;
+    data: T | null;
+}
+export declare function useCards(): {
+    fetchCards: () => Promise<ApiResponse<{
+        data: Card[];
+    }>>;
+    deleteCard: (cardId: string) => Promise<ApiResponse<void>>;
+    cards: import("vue").ComputedRef<{
+        id: string;
+        holder_name: string;
+        last_four_digits: string;
+    }[]>;
+    loading: import("vue").ComputedRef<boolean>;
+    error: import("vue").ComputedRef<string | null>;
+};

package/dist/runtime/composables/useCards.js

@@ -0,0 +1,73 @@
+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") {
+    return message;
+  }
+  const errorMessages = [];
+  for (const [, errors] of Object.entries(message)) {
+    if (Array.isArray(errors)) {
+      errorMessages.push(...errors);
+    } else {
+      errorMessages.push(String(errors));
+    }
+  }
+  return errorMessages.join(", ");
+}
+export function useCards() {
+  const store = useCardsStore();
+  const { get, del } = useApi();
+  async function fetchCards() {
+    store.setLoading(true);
+    store.setError(null);
+    try {
+      const response = await get("/customer/cards");
+      if (response.status === "Success" && response.data) {
+        store.setCards(response.data.data);
+        return response;
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        store.setError(errorMessage);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      console.error("Fetch cards error:", error);
+      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to fetch cards";
+      store.setError(errorMessage);
+      throw new Error(errorMessage);
+    } finally {
+      store.setLoading(false);
+    }
+  }
+  async function deleteCard(cardId) {
+    store.setLoading(true);
+    store.setError(null);
+    try {
+      const response = await del(`/customer/cards/${cardId}`);
+      if (response.status === "Success") {
+        store.removeCard(cardId);
+        return response;
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        store.setError(errorMessage);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      console.error("Delete card error:", error);
+      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to delete card";
+      store.setError(errorMessage);
+      throw new Error(errorMessage);
+    } finally {
+      store.setLoading(false);
+    }
+  }
+  return {
+    fetchCards,
+    deleteCard,
+    cards: computed(() => store.cards),
+    loading: computed(() => store.loading),
+    error: computed(() => store.error)
+  };
+}

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

@@ -0,0 +1,23 @@
+import type { FetchOptions } from "ofetch";
+export declare const useClientApi: () => {
+    get: <T>(url: string, options?: FetchOptions, extraHeaders?: Record<string, string>) => Promise<T>;
+    post: <T>(url: string, data: any, options?: FetchOptions, extraHeaders?: Record<string, string>) => Promise<T>;
+    put: <T>(url: string, data: any, options?: FetchOptions, extraHeaders?: Record<string, string>) => Promise<T>;
+    delete: <T>(url: string, options?: FetchOptions, extraHeaders?: Record<string, string>) => Promise<T>;
+    withShippingCountry: (country: string) => {
+        get: <T>(url: string, options?: FetchOptions) => Promise<T>;
+        post: <T>(url: string, data: any, options?: FetchOptions) => Promise<T>;
+        put: <T>(url: string, data: any, options?: FetchOptions) => Promise<T>;
+        delete: <T>(url: string, options?: FetchOptions) => Promise<T>;
+    };
+    withLocation: (location: {
+        country?: string;
+        region?: string;
+        zipcode?: string;
+    }) => {
+        get: <T>(url: string, options?: FetchOptions) => Promise<T>;
+        post: <T>(url: string, data: any, options?: FetchOptions) => Promise<T>;
+        put: <T>(url: string, data: any, options?: FetchOptions) => Promise<T>;
+        delete: <T>(url: string, options?: FetchOptions) => Promise<T>;
+    };
+};

package/dist/runtime/composables/useClientApi.js

@@ -0,0 +1,53 @@
+import { useApi } from "../utils/api.js";
+export const useClientApi = () => {
+  const api = useApi();
+  const clientApi = {
+    // GET request with automatic location headers
+    get: async (url, options = {}, extraHeaders = {}) => {
+      return await api.get(url, options, extraHeaders);
+    },
+    // POST request with automatic location headers
+    post: async (url, data, options = {}, extraHeaders = {}) => {
+      return await api.post(url, data, options, extraHeaders);
+    },
+    // PUT request with automatic location headers
+    put: async (url, data, options = {}, extraHeaders = {}) => {
+      return await api.put(url, data, options, extraHeaders);
+    },
+    // DELETE request with automatic location headers
+    delete: async (url, options = {}, extraHeaders = {}) => {
+      return await api.delete(url, options, extraHeaders);
+    },
+    // Convenience method for requests with custom shipping country
+    withShippingCountry: (country) => ({
+      get: (url, options = {}) => api.get(url, options, { "shipping-country": country }),
+      post: (url, data, options = {}) => api.post(url, data, options, { "shipping-country": country }),
+      put: (url, data, options = {}) => api.put(url, data, options, { "shipping-country": country }),
+      delete: (url, options = {}) => api.delete(url, options, { "shipping-country": country })
+    }),
+    // Convenience method for requests with custom location
+    withLocation: (location) => ({
+      get: (url, options = {}) => api.get(url, options, {
+        ...location.country && { "shipping-country": location.country },
+        ...location.region && { "shipping-region": location.region },
+        ...location.zipcode && { "shipping-zipcode": location.zipcode }
+      }),
+      post: (url, data, options = {}) => api.post(url, data, options, {
+        ...location.country && { "shipping-country": location.country },
+        ...location.region && { "shipping-region": location.region },
+        ...location.zipcode && { "shipping-zipcode": location.zipcode }
+      }),
+      put: (url, data, options = {}) => api.put(url, data, options, {
+        ...location.country && { "shipping-country": location.country },
+        ...location.region && { "shipping-region": location.region },
+        ...location.zipcode && { "shipping-zipcode": location.zipcode }
+      }),
+      delete: (url, options = {}) => api.delete(url, options, {
+        ...location.country && { "shipping-country": location.country },
+        ...location.region && { "shipping-region": location.region },
+        ...location.zipcode && { "shipping-zipcode": location.zipcode }
+      })
+    })
+  };
+  return clientApi;
+};

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

@@ -0,0 +1,12 @@
+import { type Country } from '../stores/countries.js';
+export interface ApiResponse<T> {
+    status: string;
+    message: string | Record<string, string[]> | null;
+    data: T | null;
+}
+export declare function useCountries(): {
+    fetchCountries: () => Promise<ApiResponse<Country[]>>;
+    countries: import("vue").ComputedRef<any>;
+    loading: import("vue").ComputedRef<boolean>;
+    error: import("vue").ComputedRef<string | null>;
+};

package/dist/runtime/composables/useCountries.js

@@ -0,0 +1,50 @@
+import { computed } from "vue";
+import { useCountriesStore } from "../stores/countries.js";
+import { useApi } from "../utils/api.js";
+function formatErrorMessage(message) {
+  if (!message) return "An error occurred";
+  if (typeof message === "string") {
+    return message;
+  }
+  const errorMessages = [];
+  for (const [field, errors] of Object.entries(message)) {
+    if (Array.isArray(errors)) {
+      errorMessages.push(...errors);
+    } else {
+      errorMessages.push(String(errors));
+    }
+  }
+  return errorMessages.join(", ");
+}
+export function useCountries() {
+  const store = useCountriesStore();
+  const { get } = useApi();
+  async function fetchCountries() {
+    store.setLoading(true);
+    store.setError(null);
+    try {
+      const response = await get("/countries");
+      if (response.status === "Success" && response.data) {
+        store.setCountries(response.data);
+        return response;
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        store.setError(errorMessage);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      console.error("Fetch countries error:", error);
+      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to fetch countries";
+      store.setError(errorMessage);
+      throw new Error(errorMessage);
+    } finally {
+      store.setLoading(false);
+    }
+  }
+  return {
+    fetchCountries,
+    countries: computed(() => store.countries),
+    loading: computed(() => store.loading),
+    error: computed(() => store.error)
+  };
+}

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

@@ -0,0 +1,18 @@
+declare global {
+    interface Window {
+        dataLayer: any[];
+    }
+}
+export declare function GTM_page_view(to: any): void;
+export declare function GTM_view_item(product: any, price?: number, rp?: number): void;
+export declare function GTM_view_item_list(listItems?: any[]): void;
+export declare function GTM_view_cart(cart?: any): void;
+export declare function GTM_add_to_cart(lastitem?: any): void;
+export declare function GTM_remove_from_cart(lastitem?: any): void;
+export declare function GTM_begin_checkout(cart?: any): void;
+export declare function GTM_add_shipping_info(cart?: any, shipping_tier?: any): void;
+export declare function GTM_add_payment_info(cart?: any, payment_type?: string): void;
+export declare function GTM_purchase(orderData?: any, cart?: any): void;
+export declare function GTM_select_item_color(attribute: any, item?: any, group?: any): void;
+export declare function GTM_select_item_collection(attribute: any, item?: any, group?: any): void;
+export declare function GTM_Attribute_Content(content: any): void;