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

package/dist/runtime/stores/auth.js

@@ -0,0 +1,441 @@
+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 useAuthStore = defineStore("auth", {
+  state: () => ({
+    user: null,
+    token: null,
+    isAuthenticated: false,
+    _hydrated: false
+  }),
+  actions: {
+    async userLogin(userFields) {
+      try {
+        this.user = null;
+        const apiUrl = "login";
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const response = await flowrixApi.post(apiUrl, apiConfig, {
+          body: userFields
+        });
+        if (response.status == "Success") {
+          if (process.client) {
+            const token = response?.data?.access_token;
+            const customertype = response?.data?.user?.customertype?.id || 1;
+            const expiryDate = /* @__PURE__ */ new Date();
+            expiryDate.setFullYear(expiryDate.getFullYear() + 100);
+            document.cookie = `authToken=${token}; path=/; expires=${expiryDate.toUTCString()}; SameSite=None; Secure`;
+            document.cookie = `customertype=${customertype}; path=/; expires=${expiryDate.toUTCString()}; SameSite=None; Secure`;
+          }
+          this.token = response.data.access_token;
+          this.user = response.data.user;
+          this.isAuthenticated = true;
+        }
+        return response;
+      } catch (error) {
+        return error.data;
+      }
+    },
+    async signUp(userFields) {
+      try {
+        this.user = null;
+        const apiUrl = "mystore/customer/create";
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const response = await flowrixApi.post(apiUrl, apiConfig, {
+          body: userFields
+        });
+        if (response.status == "Success") {
+          const authTokenCookie = useCookie("authToken", {
+            sameSite: "none",
+            // cross-site requests
+            secure: true,
+            // must be https
+            path: "/",
+            expires: /* @__PURE__ */ new Date("2099-12-31")
+          });
+          authTokenCookie.value = response.data.access_token;
+          this.user = response.data.user;
+        }
+        return response;
+      } catch (error) {
+        return error.data;
+      }
+    },
+    async fetchProfile() {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = "mystore/customer/profile";
+        const response = await flowrixApi.get(apiUrl, apiConfig);
+        if (response.status === "Success" && response.data) {
+          this.user = response.data;
+          return response.data;
+        }
+        return null;
+      } catch (error) {
+        console.error("Fetch profile failed:", error);
+        return null;
+      }
+    },
+    async updateProfile(userData) {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = "mystore/customer/profile/update";
+        const response = await flowrixApi.post(apiUrl, apiConfig, {
+          body: userData
+        });
+        if (response.status === "Success") {
+          await this.fetchProfile();
+          return { status: response.status, message: response.message || "Profile Updated Successfully" };
+        } else {
+          const errorMessage = response.message;
+          throw new Error(errorMessage);
+        }
+      } catch (error) {
+        return error.data;
+      }
+    },
+    async fetchUserCards() {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = "mystore/customer/cards";
+        const response = await flowrixApi.get(apiUrl, apiConfig);
+        if (response.status === "Success" && response.data) {
+          this.user = response.data;
+          return response.data;
+        }
+        return null;
+      } catch (error) {
+        console.error("Fetch user cards failed:", error);
+        return null;
+      }
+    },
+    async changePassword(userData) {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = "mystore/customer/change-password";
+        const response = await flowrixApi.post(apiUrl, apiConfig, {
+          body: userData
+        });
+        if (response.status === "Success") {
+          return { status: response.status, message: response.message || "Password Update Successfully" };
+        } else {
+          const errorMessage = response.message;
+          throw new Error(errorMessage);
+        }
+      } catch (error) {
+        return error.data;
+      }
+    },
+    async deleteCard(cardId) {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = `mystore/customer/cards/${cardId}`;
+        const response = await flowrixApi.delete(apiUrl, apiConfig);
+        if (response.status === "Success") {
+          return { status: response.status, message: response.message || "Card deleted Successfully" };
+        } else {
+          const errorMessage = response.message;
+          throw new Error(errorMessage);
+        }
+      } catch (error) {
+        return error.data;
+      }
+    },
+    async fetchOrders() {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = "mystore/customer/orders";
+        const response = await flowrixApi.get(apiUrl, apiConfig);
+        if (response.status === "Success" && response.data) {
+          return response.data;
+        }
+        return null;
+      } catch (error) {
+        console.error("Fetch Orders failed:", error);
+        return null;
+      }
+    },
+    async downloadInvoice(orderNo) {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = `mystore/customer/orders/${orderNo}/tax-invoice`;
+        const response = await flowrixApi.get(apiUrl, apiConfig);
+        const blob = new Blob([response], { type: "application/pdf" });
+        const url = window.URL.createObjectURL(blob);
+        const link = document.createElement("a");
+        link.href = url;
+        link.setAttribute("download", `tax-invoice-${orderNo}.pdf`);
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+        window.URL.revokeObjectURL(url);
+        return response;
+      } catch (err) {
+        console.error("Download invoice error:", err);
+        return err.data;
+      } finally {
+      }
+    },
+    async fetchQuotations() {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = "mystore/customer/quotations";
+        const response = await flowrixApi.get(apiUrl, apiConfig);
+        if (response.status === "Success" && response.data) {
+          return response.data;
+        }
+        return null;
+      } catch (error) {
+        console.error("Fetch quotations failed:", error);
+        return null;
+      }
+    },
+    async setAddress(addressData, method = "add") {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        let response = {};
+        if (method == "update") {
+          const apiUrl = `mystore/customer/address/${addressData.id}/update`;
+          response = await flowrixApi.patch(apiUrl, apiConfig, {
+            body: addressData
+          });
+        } else if (method == "delete") {
+          const apiUrl = `mystore/customer/address/${addressData.id}/delete`;
+          response = await flowrixApi.patch(apiUrl, apiConfig);
+        } else if (method == "setshipping") {
+          const apiUrl = `mystore/customer/address/${addressData.id}/setshipping`;
+          response = await flowrixApi.post(apiUrl, apiConfig);
+        } else {
+          const apiUrl = "mystore/customer/address/add";
+          response = await flowrixApi.post(apiUrl, apiConfig, {
+            body: addressData
+          });
+        }
+        if (response.status === "Success") {
+          await this.fetchProfile();
+          return response;
+        } else {
+          return response;
+        }
+      } catch (error) {
+        return error.data;
+      }
+    },
+    // Password Reset APIs
+    async verifyEmail(email) {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const response = await flowrixApi.post("verify-email", apiConfig, {
+          body: { 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 verifyToken(email, token) {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const response = await flowrixApi.post("verify-token", apiConfig, {
+          body: { 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 resetPassword(token, password, password_confirmation) {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const response = await flowrixApi.post("reset-password", apiConfig, {
+          body: {
+            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
+        };
+      }
+    },
+    loadAuth() {
+      if (process.client) {
+        const token = localStorage.getItem("auth_token");
+        const userData = localStorage.getItem("auth_user");
+        if (token) {
+          this.token = token;
+          this.isAuthenticated = true;
+          if (userData) {
+            try {
+              this.user = JSON.parse(userData);
+            } catch (error) {
+              console.error("Error parsing stored user data:", error);
+              localStorage.removeItem("auth_user");
+            }
+          }
+        }
+        this._hydrated = true;
+      }
+    },
+    logout() {
+      this.user = null;
+      this.token = null;
+      this.isAuthenticated = false;
+      this._hydrated = true;
+      if (process.client) {
+        localStorage.removeItem("auth_token");
+        localStorage.removeItem("auth_user");
+      }
+    },
+    setHydrated() {
+      this._hydrated = true;
+    }
+  },
+  getters: {
+    getUser: (state) => state.user,
+    getToken: (state) => state.token,
+    isLoggedIn: (state) => state.isAuthenticated,
+    isHydrated: (state) => state._hydrated
+  },
+  persist: {
+    enabled: true,
+    key: "user",
+    storage: typeof window !== "undefined" ? localStorage : void 0
+  }
+});

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

@@ -0,0 +1,15 @@
+export interface Card {
+    id: string;
+    holder_name: string;
+    last_four_digits: string;
+}
+export declare const useCardsStore: import("pinia").StoreDefinition<"cards", {
+    cards: Card[];
+    loading: boolean;
+    error: string | null;
+}, {}, {
+    setCards(cards: Card[]): void;
+    removeCard(cardId: string): void;
+    setLoading(loading: boolean): void;
+    setError(error: string | null): void;
+}>;

package/dist/runtime/stores/cards.js

@@ -0,0 +1,22 @@
+import { defineStore } from "pinia";
+export const useCardsStore = defineStore("cards", {
+  state: () => ({
+    cards: [],
+    loading: false,
+    error: null
+  }),
+  actions: {
+    setCards(cards) {
+      this.cards = cards;
+    },
+    removeCard(cardId) {
+      this.cards = this.cards.filter((c) => c.id !== cardId);
+    },
+    setLoading(loading) {
+      this.loading = loading;
+    },
+    setError(error) {
+      this.error = error;
+    }
+  }
+});

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

@@ -0,0 +1,7 @@
+export declare const useCompareStore: import("pinia").StoreDefinition<"compareStore", {
+    comparedProducts: never[];
+}, {}, {
+    initFromLocalStorage(): void;
+    toggleProduct(product: any): void;
+    clearCompare(): void;
+}>;

package/dist/runtime/stores/compareStore.js

@@ -0,0 +1,45 @@
+import { defineStore } from "pinia";
+export const useCompareStore = defineStore("compareStore", {
+  state: () => ({
+    comparedProducts: []
+  }),
+  actions: {
+    initFromLocalStorage() {
+      if (typeof window !== "undefined") {
+        const saved = localStorage.getItem("comparedProducts");
+        if (saved) {
+          try {
+            this.comparedProducts = JSON.parse(saved);
+          } catch (e) {
+            console.error("Error parsing localStorage data:", e);
+          }
+        }
+      }
+    },
+    toggleProduct(product) {
+      if (!product || !product.id) {
+        console.warn("\u26A0\uFE0F Invalid product passed to toggleProduct:", product);
+        return;
+      }
+      const exists = this.comparedProducts.find((p) => p.id === product.id);
+      if (exists) {
+        this.comparedProducts = this.comparedProducts.filter((p) => p.id !== product.id);
+      } else {
+        if (this.comparedProducts.length < 4) {
+          this.comparedProducts.push(product);
+        } else {
+          alert("You can only compare up to 4 products at a time.");
+        }
+      }
+      if (typeof window !== "undefined") {
+        localStorage.setItem("comparedProducts", JSON.stringify(this.comparedProducts));
+      }
+    },
+    clearCompare() {
+      this.comparedProducts.splice(0, this.comparedProducts.length);
+      if (typeof window !== "undefined") {
+        localStorage.removeItem("comparedProducts");
+      }
+    }
+  }
+});

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

@@ -0,0 +1,8 @@
+import type { Country } from '../types/user.js';
+export declare const useCountriesStore: import("pinia").StoreDefinition<"countries", {
+    countries: Country[];
+    loading: boolean;
+    error: string | null;
+}, {}, {
+    getCountries(): Promise<any>;
+}>;

package/dist/runtime/stores/countries.js

@@ -0,0 +1,15 @@
+import { defineStore } from "pinia";
+export const useCountriesStore = defineStore("countries", {
+  state: () => ({
+    countries: [],
+    loading: false,
+    error: null
+  }),
+  actions: {
+    async getCountries() {
+      const response = await $fetch("/api/countries");
+      this.countries = response;
+      return response;
+    }
+  }
+});

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

@@ -0,0 +1,26 @@
+export { useAddressesStore } from './addresses.js';
+export type { Address as AddressType } from './addresses.js';
+export { useAuthStore } from './auth.js';
+export type { Address as AuthAddress, User, Country, AuthState } from './auth.js';
+export * from './Booking.js';
+export * from './cards.js';
+export * from './Cart.js';
+export * from './Categories.js';
+export * from './Checkout.js';
+export * from './compareStore.js';
+export * from './countries.js';
+export * from './IpLocation.js';
+export * from './locations.js';
+export * from './NavMenu.js';
+export * from './orders.js';
+export * from './product.js';
+export * from './quotations.js';
+export * from './Search.js';
+export * from './Services.js';
+export * from './subscriptions.js';
+export * from './useCompanyProfile.js';
+export * from './useNavMenuStore.js';
+export * from './Utilities.js';
+export * from './webforms.js';
+export * from './wishlists.js';
+export * from './product/slug.js';

package/dist/runtime/stores/index.js

@@ -0,0 +1,24 @@
+export { useAddressesStore } from "./addresses.js";
+export { useAuthStore } from "./auth.js";
+export * from "./Booking.js";
+export * from "./cards.js";
+export * from "./Cart.js";
+export * from "./Categories.js";
+export * from "./Checkout.js";
+export * from "./compareStore.js";
+export * from "./countries.js";
+export * from "./IpLocation.js";
+export * from "./locations.js";
+export * from "./NavMenu.js";
+export * from "./orders.js";
+export * from "./product.js";
+export * from "./quotations.js";
+export * from "./Search.js";
+export * from "./Services.js";
+export * from "./subscriptions.js";
+export * from "./useCompanyProfile.js";
+export * from "./useNavMenuStore.js";
+export * from "./Utilities.js";
+export * from "./webforms.js";
+export * from "./wishlists.js";
+export * from "./product/slug.js";

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

@@ -0,0 +1,11 @@
+export interface LocationData {
+}
+export declare const useLocationsStore: import("pinia").StoreDefinition<"locations", {
+    location: LocationData | null;
+    loading: boolean;
+    error: string | null;
+}, {}, {
+    setLocation(location: LocationData | null): void;
+    setLoading(loading: boolean): void;
+    setError(error: string | null): void;
+}>;

package/dist/runtime/stores/locations.js

@@ -0,0 +1,19 @@
+import { defineStore } from "pinia";
+export const useLocationsStore = defineStore("locations", {
+  state: () => ({
+    location: null,
+    loading: false,
+    error: null
+  }),
+  actions: {
+    setLocation(location) {
+      this.location = location;
+    },
+    setLoading(loading) {
+      this.loading = loading;
+    },
+    setError(error) {
+      this.error = error;
+    }
+  }
+});

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

@@ -0,0 +1,16 @@
+export interface Order {
+    id: number;
+    order_no: string;
+    order_status: string;
+    payment_method: string;
+    grandtotal: number;
+}
+export declare const useOrdersStore: import("pinia").StoreDefinition<"orders", {
+    orders: Order[];
+    loading: boolean;
+    error: string | null;
+}, {}, {
+    setOrders(orders: Order[]): void;
+    setLoading(loading: boolean): void;
+    setError(error: string | null): void;
+}>;

package/dist/runtime/stores/orders.js

@@ -0,0 +1,19 @@
+import { defineStore } from "pinia";
+export const useOrdersStore = defineStore("orders", {
+  state: () => ({
+    orders: [],
+    loading: false,
+    error: null
+  }),
+  actions: {
+    setOrders(orders) {
+      this.orders = orders;
+    },
+    setLoading(loading) {
+      this.loading = loading;
+    },
+    setError(error) {
+      this.error = error;
+    }
+  }
+});