flowrix 1.0.1-beta.85 → 1.0.1-beta.86

package/dist/runtime/composables/Customer/useShippingAddress.js

@@ -0,0 +1,145 @@
+import { ref, computed } from "vue";
+import { useAuthStore } from "../../stores/auth.js";
+export function useShippingAddress() {
+  const authStore = useAuthStore();
+  const user = computed(() => authStore.user);
+  const shippingAddresses = computed(() => {
+    return user.value?.addresses?.filter((a) => a.billing == 0) ?? [];
+  });
+  const showModal = ref(false);
+  const isEditMode = ref(false);
+  const showDeleteModal = ref(false);
+  const currentAddress = ref(null);
+  const submitAddressReturn = ref(null);
+  const loading = ref(false);
+  const clearMessages = () => {
+    submitAddressReturn.value = null;
+  };
+  const openAddModal = () => {
+    clearMessages();
+    isEditMode.value = false;
+    currentAddress.value = {
+      id: null,
+      firstname: "",
+      lastname: "",
+      address: "",
+      suburb: "",
+      state: "",
+      state_id: null,
+      country: "Australia",
+      country_id: "",
+      postcode: "",
+      mobile: "",
+      shipping: 1,
+      billing: 0
+    };
+    showModal.value = true;
+  };
+  const openEditModal = (address) => {
+    clearMessages();
+    isEditMode.value = true;
+    currentAddress.value = {
+      ...address,
+      saddress: address.address
+    };
+    showModal.value = true;
+  };
+  const closeModal = () => {
+    clearMessages();
+    showModal.value = false;
+    currentAddress.value = null;
+  };
+  const openDeleteModal = (address) => {
+    clearMessages();
+    currentAddress.value = address;
+    showDeleteModal.value = true;
+  };
+  const closeDeleteModal = () => {
+    clearMessages();
+    showDeleteModal.value = false;
+    currentAddress.value = null;
+  };
+  const submitAddress = async () => {
+    if (!currentAddress.value) return;
+    loading.value = true;
+    clearMessages();
+    try {
+      const method = currentAddress.value.id ? "update" : "add";
+      submitAddressReturn.value = await authStore.setAddress(currentAddress.value, method);
+      if (submitAddressReturn.value.status === "Success") {
+        await authStore.fetchProfile();
+        if (method === "update") {
+          submitAddressReturn.value.message = "Address Updated Successfully";
+        } else {
+          submitAddressReturn.value.message = "Address Created Successfully";
+        }
+        showModal.value = false;
+      }
+    } catch (error) {
+      console.error("Address submission error:", error);
+    } finally {
+      loading.value = false;
+    }
+  };
+  const setShipping = async (address) => {
+    loading.value = true;
+    clearMessages();
+    try {
+      submitAddressReturn.value = await authStore.setAddress(address, "setshipping");
+      if (submitAddressReturn.value.status === "Success") {
+        await authStore.fetchProfile();
+        submitAddressReturn.value.message = "Shipping Address Updated Successfully";
+      }
+    } catch (error) {
+      console.error("Set shipping error:", error);
+    } finally {
+      loading.value = false;
+    }
+  };
+  const deleteAddress = async () => {
+    if (!currentAddress.value) return;
+    loading.value = true;
+    clearMessages();
+    try {
+      submitAddressReturn.value = await authStore.setAddress(currentAddress.value, "delete");
+      if (submitAddressReturn.value.status === "Success") {
+        await authStore.fetchProfile();
+        showDeleteModal.value = false;
+      }
+    } catch (error) {
+      console.error("Delete address error:", error);
+    } finally {
+      loading.value = false;
+    }
+  };
+  const autoClearMessages = () => {
+    if (submitAddressReturn.value?.status !== void 0) {
+      setTimeout(() => {
+        submitAddressReturn.value = null;
+      }, 5e3);
+    }
+  };
+  return {
+    // State
+    showModal,
+    isEditMode,
+    showDeleteModal,
+    currentAddress,
+    submitAddressReturn,
+    loading,
+    // Computed
+    user,
+    shippingAddresses,
+    // Methods
+    clearMessages,
+    openAddModal,
+    openEditModal,
+    closeModal,
+    openDeleteModal,
+    closeDeleteModal,
+    submitAddress,
+    setShipping,
+    deleteAddress,
+    autoClearMessages
+  };
+}

package/dist/runtime/composables/Customer/useUpdatePassword.d.ts

@@ -0,0 +1,21 @@
+export declare function useUpdatePassword(): {
+    form: import("vue").Ref<{
+        currentPassword: string;
+        newPassword: string;
+        confirmPassword: string;
+    }, {
+        currentPassword: string;
+        newPassword: string;
+        confirmPassword: string;
+    } | {
+        currentPassword: string;
+        newPassword: string;
+        confirmPassword: string;
+    }>;
+    loading: import("vue").Ref<boolean, boolean>;
+    errorMessage: import("vue").Ref<string, string>;
+    successMessage: import("vue").Ref<string, string>;
+    updatePassword: () => Promise<boolean>;
+    clearMessages: () => void;
+    resetForm: () => void;
+};

package/dist/runtime/composables/Customer/useUpdatePassword.js

@@ -0,0 +1,94 @@
+import { ref } from "vue";
+import { useAuthStore } from "../../stores/auth.js";
+export function useUpdatePassword() {
+  const authStore = useAuthStore();
+  const loading = ref(false);
+  const errorMessage = ref("");
+  const successMessage = ref("");
+  const form = ref({
+    currentPassword: "",
+    newPassword: "",
+    confirmPassword: ""
+  });
+  const clearMessages = () => {
+    errorMessage.value = "";
+    successMessage.value = "";
+  };
+  const resetForm = () => {
+    form.value = {
+      currentPassword: "",
+      newPassword: "",
+      confirmPassword: ""
+    };
+    clearMessages();
+  };
+  const validateForm = () => {
+    if (!form.value.currentPassword?.trim() || !form.value.newPassword?.trim() || !form.value.confirmPassword?.trim()) {
+      errorMessage.value = "All password fields are required!";
+      return false;
+    }
+    if (form.value.newPassword !== form.value.confirmPassword) {
+      errorMessage.value = "New password and confirm password do not match!";
+      return false;
+    }
+    if (form.value.newPassword.length < 8) {
+      errorMessage.value = "New password must be at least 8 characters long!";
+      return false;
+    }
+    return true;
+  };
+  const updatePassword = async () => {
+    if (!validateForm()) {
+      return false;
+    }
+    loading.value = true;
+    clearMessages();
+    try {
+      const requestBody = {
+        current_password: form.value.currentPassword.trim(),
+        password: form.value.newPassword.trim(),
+        password_confirmation: form.value.confirmPassword.trim()
+      };
+      const response = await authStore.changePassword(requestBody);
+      if (response && response?.status === "Success") {
+        successMessage.value = response.message || "Password updated successfully!";
+        resetForm();
+        return true;
+      }
+      if (response) {
+        successMessage.value = response.message || "Password updated successfully!";
+        resetForm();
+        return true;
+      } else if (response && response.status === "Error") {
+        errorMessage.value = response.message || "Failed to update password. Please try again.";
+        return false;
+      } else {
+        errorMessage.value = "Unexpected response from server. Please try again.";
+        return false;
+      }
+    } catch (err) {
+      console.error("Unexpected error:", err);
+      if (err.data && err.data.status === "Error") {
+        errorMessage.value = err.data.message || "Failed to update password. Please try again.";
+      } else if (err.message) {
+        errorMessage.value = err.message;
+      } else {
+        errorMessage.value = "An unexpected error occurred while updating your password.";
+      }
+      return false;
+    } finally {
+      loading.value = false;
+    }
+  };
+  return {
+    // State
+    form,
+    loading,
+    errorMessage,
+    successMessage,
+    // Methods
+    updatePassword,
+    clearMessages,
+    resetForm
+  };
+}

package/dist/runtime/composables/Customer/useUserCards.d.ts

@@ -0,0 +1,22 @@
+export interface Card {
+    id: string;
+    holder_name: string;
+    last_four_digits: string;
+    [key: string]: any;
+}
+export declare function useUserCards(): {
+    cards: import("vue").ComputedRef<{
+        [x: string]: any;
+        id: string;
+        holder_name: string;
+        last_four_digits: string;
+    }[]>;
+    loading: import("vue").Ref<boolean, boolean>;
+    deletingCardId: import("vue").Ref<string | null, string | null>;
+    errorMessage: import("vue").Ref<string, string>;
+    successMessage: import("vue").Ref<string, string>;
+    hasCards: import("vue").ComputedRef<boolean>;
+    fetchCards: () => Promise<void>;
+    deleteCard: (cardId: string) => Promise<boolean>;
+    clearMessages: () => void;
+};

package/dist/runtime/composables/Customer/useUserCards.js

@@ -0,0 +1,65 @@
+import { ref, computed } from "vue";
+import { useAuthStore } from "../../stores/auth.js";
+export function useUserCards() {
+  const authStore = useAuthStore();
+  const cards = ref([]);
+  const loading = ref(false);
+  const deletingCardId = ref(null);
+  const errorMessage = ref("");
+  const successMessage = ref("");
+  const cardsData = computed(() => cards.value || []);
+  const hasCards = computed(() => cards.value && cards.value.length > 0);
+  const clearMessages = () => {
+    errorMessage.value = "";
+    successMessage.value = "";
+  };
+  const fetchCards = async () => {
+    loading.value = true;
+    clearMessages();
+    try {
+      const cardsData2 = await authStore.fetchUserCards();
+      cards.value = Array.isArray(cardsData2) ? cardsData2 : [];
+    } catch (error) {
+      console.error("Failed to fetch cards:", error);
+      cards.value = [];
+      errorMessage.value = "Failed to load cards. Please try again.";
+    } finally {
+      loading.value = false;
+    }
+  };
+  const deleteCard = async (cardId) => {
+    deletingCardId.value = cardId;
+    clearMessages();
+    try {
+      const response = await authStore.deleteCard(cardId);
+      if (response.status === "Success") {
+        successMessage.value = response.message || "Card deleted successfully!";
+        cards.value = cards.value.filter((card) => card.id !== cardId);
+        return true;
+      } else {
+        errorMessage.value = response.message || "Failed to delete card. Please try again.";
+        return false;
+      }
+    } catch (error) {
+      console.error("Delete card error:", error);
+      errorMessage.value = error.message || "Failed to delete card. Please try again.";
+      return false;
+    } finally {
+      deletingCardId.value = null;
+    }
+  };
+  return {
+    // State
+    cards: cardsData,
+    loading,
+    deletingCardId,
+    errorMessage,
+    successMessage,
+    // Computed
+    hasCards,
+    // Methods
+    fetchCards,
+    deleteCard,
+    clearMessages
+  };
+}

package/dist/runtime/composables/Customer/useWishlists.d.ts

@@ -0,0 +1,25 @@
+import { type Wishlist, type WishlistProduct, type CreateWishlistData, type UpdateWishlistData, type AddToWishlistData, type ApiResponse } from '../../stores/wishlists.js';
+export declare function useWishlists(): {
+    fetchWishlists: (force?: boolean) => Promise<ApiResponse<Wishlist[]>>;
+    fetchWishlistProducts: (listId: number) => Promise<ApiResponse<{
+        id: number;
+        title: string;
+        default: boolean;
+        created_at: string;
+        products: WishlistProduct[];
+    }>>;
+    createWishlist: (data: CreateWishlistData) => Promise<ApiResponse<Wishlist>>;
+    addToWishlist: (listId: number, productSlug: string, data?: AddToWishlistData) => Promise<ApiResponse<WishlistProduct>>;
+    removeFromWishlist: (listId: number, productSlug: string) => Promise<ApiResponse<void>>;
+    updateWishlist: (id: number, data: UpdateWishlistData) => Promise<ApiResponse<Wishlist>>;
+    deleteWishlist: (id: number) => Promise<ApiResponse<void>>;
+    wishlists: import("vue").ComputedRef<{
+        id: number;
+        title: string;
+        default: boolean;
+        created_at: string;
+    }[]>;
+    wishlistProducts: (listId: number) => WishlistProduct[];
+    loading: import("vue").ComputedRef<boolean>;
+    error: import("vue").ComputedRef<string | null>;
+};

package/dist/runtime/composables/Customer/useWishlists.js

@@ -0,0 +1,183 @@
+import { computed } from "vue";
+import {
+  useWishlistsStore
+} from "../../stores/wishlists.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 useWishlists() {
+  const store = useWishlistsStore();
+  async function fetchWishlists(force) {
+    store.setLoading(true);
+    store.setError(null);
+    try {
+      const response = await store.fetchWishlists(force || false);
+      if (response.status === "Success") {
+        return response;
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        store.setError(errorMessage);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      console.error("Fetch wishlists error:", error);
+      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to fetch wishlists";
+      store.setError(errorMessage);
+      throw new Error(errorMessage);
+    } finally {
+      store.setLoading(false);
+    }
+  }
+  async function fetchWishlistProducts(listId) {
+    store.setLoading(true);
+    store.setError(null);
+    try {
+      const response = await store.fetchWishlistProducts(listId);
+      if (response.status === "Success") {
+        return response;
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        store.setError(errorMessage);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      console.error("Fetch wishlist products error:", error);
+      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to fetch wishlist products";
+      store.setError(errorMessage);
+      throw new Error(errorMessage);
+    } finally {
+      store.setLoading(false);
+    }
+  }
+  async function createWishlist(data) {
+    store.setLoading(true);
+    store.setError(null);
+    try {
+      const response = await store.createWishlist(data);
+      if (response.status === "Success") {
+        return response;
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        store.setError(errorMessage);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      console.error("Create wishlist error:", error);
+      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to create wishlist";
+      store.setError(errorMessage);
+      throw new Error(errorMessage);
+    } finally {
+      store.setLoading(false);
+    }
+  }
+  async function addToWishlist(listId, productSlug, data = {}) {
+    store.setLoading(true);
+    store.setError(null);
+    try {
+      const response = await store.addToWishlist(listId, productSlug, data);
+      if (response.status === "Success") {
+        return response;
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        store.setError(errorMessage);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      console.error("Add to wishlist error:", error);
+      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to add to wishlist";
+      store.setError(errorMessage);
+      throw new Error(errorMessage);
+    } finally {
+      store.setLoading(false);
+    }
+  }
+  async function removeFromWishlist(listId, productSlug) {
+    store.setLoading(true);
+    store.setError(null);
+    try {
+      const response = await store.removeFromWishlist(listId, productSlug);
+      if (response.status === "Success") {
+        return response;
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        store.setError(errorMessage);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      console.error("Remove from wishlist error:", error);
+      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to remove from wishlist";
+      store.setError(errorMessage);
+      throw new Error(errorMessage);
+    } finally {
+      store.setLoading(false);
+    }
+  }
+  async function updateWishlist(id, data) {
+    store.setLoading(true);
+    store.setError(null);
+    try {
+      const response = await store.updateWishlist(id, data);
+      if (response.status === "Success") {
+        return response;
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        store.setError(errorMessage);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      console.error("Update wishlist error:", error);
+      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to update wishlist";
+      store.setError(errorMessage);
+      throw new Error(errorMessage);
+    } finally {
+      store.setLoading(false);
+    }
+  }
+  async function deleteWishlist(id) {
+    store.setLoading(true);
+    store.setError(null);
+    try {
+      const response = await store.deleteWishlist(id);
+      if (response.status === "Success") {
+        return response;
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        store.setError(errorMessage);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      console.error("Delete wishlist error:", error);
+      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to delete wishlist";
+      store.setError(errorMessage);
+      throw new Error(errorMessage);
+    } finally {
+      store.setLoading(false);
+    }
+  }
+  return {
+    fetchWishlists,
+    fetchWishlistProducts,
+    createWishlist,
+    addToWishlist,
+    removeFromWishlist,
+    updateWishlist,
+    deleteWishlist,
+    wishlists: computed(() => store.getWishlists),
+    // Fixed: Remove extra computed wrapper - direct getter for reactivity
+    wishlistProducts: (listId) => store.getWishlistProducts(listId),
+    loading: computed(() => store.isLoading),
+    error: computed(() => store.getError)
+  };
+}

package/dist/runtime/composables/Extras/useCountry.d.ts

@@ -0,0 +1,11 @@
+interface Country {
+    id: number;
+    name: string;
+}
+interface UseCountryReturn {
+    data: Ref<Country[] | null>;
+    error: Ref<Error | null>;
+    refresh: () => Promise<void>;
+}
+export declare const useCountry: () => UseCountryReturn;
+export {};

package/dist/runtime/composables/Extras/useCountry.js

@@ -0,0 +1,12 @@
+import { useFetch } from "#imports";
+export const useCountry = () => {
+  const { data, error, refresh } = useFetch("/api/checkout/countries", {
+    server: true,
+    key: "countries"
+  });
+  return {
+    data,
+    error,
+    refresh
+  };
+};

package/dist/runtime/composables/Extras/useDateFormatter.d.ts

@@ -0,0 +1,4 @@
+export declare const useDateFormatter: () => {
+    formatDate: (dateString: string) => string;
+    parseDate: (dateString: string) => string;
+};

package/dist/runtime/composables/Extras/useDateFormatter.js

@@ -0,0 +1,20 @@
+export const useDateFormatter = () => {
+  const formatDate = (dateString) => {
+    const date = new Date(dateString);
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    return `${year}-${month}-${day}`;
+  };
+  const parseDate = (dateString) => {
+    const [year, month, day] = dateString.split("-").map(Number);
+    if (isNaN(year) || isNaN(month) || isNaN(day)) {
+      throw new Error("Invalid date string format");
+    }
+    return new Date(year, month - 1, day).toDateString();
+  };
+  return {
+    formatDate,
+    parseDate
+  };
+};

package/dist/runtime/composables/Extras/useNumberOnly.d.ts

@@ -0,0 +1,5 @@
+export declare function useNumberOnly(): {
+    inputValue: import("vue").Ref<string, string>;
+    errorMessage: import("vue").Ref<string, string>;
+    handleInput: (event: Event) => void;
+};

package/dist/runtime/composables/Extras/useNumberOnly.js

@@ -0,0 +1,21 @@
+import { ref } from "vue";
+export function useNumberOnly() {
+  const inputValue = ref("");
+  const errorMessage = ref("");
+  const handleInput = (event) => {
+    const target = event.target;
+    const sanitizedValue = target.value.replace(/[^0-9]/g, "");
+    if (sanitizedValue !== target.value) {
+      errorMessage.value = "Please enter numbers only.";
+    } else {
+      errorMessage.value = "";
+    }
+    inputValue.value = sanitizedValue;
+    target.value = sanitizedValue;
+  };
+  return {
+    inputValue,
+    errorMessage,
+    handleInput
+  };
+}

package/dist/runtime/composables/Extras/usePasswordFormatter.d.ts

@@ -0,0 +1,8 @@
+import { type Ref } from "vue";
+export declare function usePasswordFormatter(password: Ref<string | null>, inputData: any): {
+    passwordStrength: import("vue").ComputedRef<"Password must be 8 characters" | "Strong" | "Medium" | "Weak">;
+    passwordStrengthClass: import("vue").ComputedRef<"bg-danger" | "bg-success" | "bg-warning">;
+    passwordStrengthValue: import("vue").ComputedRef<number>;
+    passwordStrengthWidth: import("vue").ComputedRef<string>;
+    passwordStrengthTextColor: import("vue").ComputedRef<"text-danger" | "text-success" | "text-black">;
+};