flowrix 1.0.0

package/dist/runtime/stores/IpLocation.js

@@ -0,0 +1,29 @@
+import { defineStore } from "pinia";
+export const useIpLocation = defineStore("IpLocation", {
+  state: () => ({
+    location: null
+  }),
+  actions: {
+    async getLocation() {
+      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;
+          }
+        }
+      } catch (error) {
+        console.error("Error fetching data:", error);
+        this.location = null;
+      }
+    }
+  },
+  persist: true
+});

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

@@ -0,0 +1,15 @@
+export interface NavMenuState {
+    Menu: {
+        location: string;
+        items: MenuItem[];
+    }[];
+}
+export interface MenuItem {
+    title: string;
+    url: string;
+    sortorder: number;
+    children?: MenuItem[];
+}
+export declare const useNavMenu: import("pinia").StoreDefinition<"NavMenu", NavMenuState, {}, {
+    navMenu(id: number, location?: string): Promise<void>;
+}>;

package/dist/runtime/stores/NavMenu.js

@@ -0,0 +1,26 @@
+import { defineStore } from "pinia";
+export const useNavMenu = defineStore("NavMenu", {
+  state: () => ({
+    Menu: []
+  }),
+  actions: {
+    async navMenu(id, location = "header") {
+      try {
+        const existingMenu = this.Menu.find((menu) => menu.location === location);
+        if (!existingMenu) {
+          const response = await $fetch(`/api/nav/${id}/links`, {
+            method: "GET",
+            headers: {
+              "Content-Type": "application/json"
+            }
+          });
+          if (response.status === "Success") {
+            this.Menu.push({ location, items: response.data });
+          }
+        }
+      } catch (error) {
+        console.error("Error fetching data:", error);
+      }
+    }
+  }
+});

package/dist/runtime/stores/Search.js

@@ -0,0 +1,33 @@
+import { useApi } from "../utils/api.js";
+import { defineStore } from "pinia";
+export const useSearchStore = defineStore("SearchStore", {
+  state: () => ({
+    data: []
+  }),
+  actions: {
+    async fetchSearchData(query) {
+      const { get } = useApi();
+      try {
+        this.data = [];
+        const params = new URLSearchParams();
+        params.append("search", query);
+        params.append("ProductType[]", "custom");
+        params.append("ProductType[]", "simple");
+        params.append("ProductType[]", "bundle");
+        const apiUrl = `search?${params.toString()}`;
+        const response = await get(apiUrl);
+        if (response?.status === "Success" && Array.isArray(response.data.products.data)) {
+          this.data = response.data.products.data;
+          return this.data;
+        } else {
+          this.data = [];
+          return [];
+        }
+      } catch (error) {
+        console.error("Error fetching search data:", error);
+        this.data = [];
+        throw error;
+      }
+    }
+  }
+});

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

@@ -0,0 +1,7 @@
+export declare const useServiceStore: import("pinia").StoreDefinition<"ServiceStore", {
+    services: never[];
+    availability: boolean;
+}, {}, {
+    getAllServices(): Promise<void>;
+    checkAvailability(data: any): Promise<any>;
+}>;

package/dist/runtime/stores/Services.js

@@ -0,0 +1,49 @@
+import { defineStore } from "pinia";
+import { useCheckoutStore } from "./Checkout.js";
+export const useServiceStore = defineStore("ServiceStore", {
+  state: () => ({
+    services: [],
+    availability: false
+  }),
+  actions: {
+    async getAllServices() {
+      try {
+        const apiUrl = `/api/services/getall`;
+        const response = await $fetch(apiUrl, {
+          method: "GET",
+          headers: {
+            "Content-Type": "application/json"
+          }
+        });
+        if (response.status == "Success") {
+          this.services = response.data;
+        } else {
+          this.services = null;
+        }
+      } catch (error) {
+        console.error("Error fetching data:", error);
+      }
+    },
+    async checkAvailability(data) {
+      try {
+        const apiUrl = `/api/services/availability`;
+        const response = await $fetch(apiUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: data
+        });
+        if (response.status == "Success") {
+          this.availability = response.data.service;
+          useCheckoutStore().saveToCheckoutSession(data);
+          return response.data;
+        } else {
+          this.data = null;
+        }
+      } catch (error) {
+        console.error("Error fetching data:", error);
+      }
+    }
+  }
+});

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

@@ -0,0 +1,5 @@
+interface UtilitiesData {
+    loading: any;
+}
+export declare const useUtilities: import("pinia").StoreDefinition<"Utilities", UtilitiesData, {}, {}>;
+export {};

package/dist/runtime/stores/Utilities.js

@@ -0,0 +1,11 @@
+import { defineStore } from "pinia";
+export const useUtilities = defineStore("Utilities", {
+  state: () => ({
+    loading: false,
+    productloading: false
+  }),
+  actions: {},
+  persist: {
+    key: "Utilities"
+  }
+});

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

@@ -0,0 +1,15 @@
+export interface Address {
+    id: number;
+}
+export declare const useAddressesStore: import("pinia").StoreDefinition<"addresses", {
+    addresses: Address[];
+    loading: boolean;
+    error: string | null;
+}, {}, {
+    setAddresses(addresses: Address[]): void;
+    addAddress(address: Address): void;
+    updateAddress(updatedAddress: Address): void;
+    removeAddress(id: number): void;
+    setLoading(loading: boolean): void;
+    setError(error: string | null): void;
+}>;

package/dist/runtime/stores/addresses.js

@@ -0,0 +1,31 @@
+import { defineStore } from "pinia";
+export const useAddressesStore = defineStore("addresses", {
+  state: () => ({
+    addresses: [],
+    loading: false,
+    error: null
+  }),
+  actions: {
+    setAddresses(addresses) {
+      this.addresses = addresses;
+    },
+    addAddress(address) {
+      this.addresses.push(address);
+    },
+    updateAddress(updatedAddress) {
+      const index = this.addresses.findIndex((a) => a.id === updatedAddress.id);
+      if (index !== -1) {
+        this.addresses[index] = updatedAddress;
+      }
+    },
+    removeAddress(id) {
+      this.addresses = this.addresses.filter((a) => a.id !== id);
+    },
+    setLoading(loading) {
+      this.loading = loading;
+    },
+    setError(error) {
+      this.error = error;
+    }
+  }
+});

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

@@ -0,0 +1,62 @@
+export interface Address {
+    id: number;
+    fullname: string | null;
+    firstname: string;
+    middlename: string | null;
+    lastname: string;
+    address: string;
+    suburb: string;
+    state: string | null;
+    state_id: number | null;
+    country: string;
+    country_id: number;
+    postcode: string;
+    mobile: string;
+    shipping: number;
+    billing: number;
+}
+export interface Country {
+    id: number;
+    name: string;
+    emoji: string;
+}
+export interface User {
+    id: number;
+    fullname: string;
+    firstname: string;
+    lastname: string;
+    email: string;
+    avatar: string;
+    country_id: number | null;
+    country: Country | null;
+    state_id: number | null;
+    state: string | null;
+    suburb: string | null;
+    dob: string | null;
+    phone: string | null;
+    address: string | null;
+    mobile: string | null;
+    company: string | null;
+    addresses: Address[];
+    created_at: string;
+}
+export interface AuthState {
+    user: User | null;
+    token: string | null;
+    isAuthenticated: boolean;
+    _hydrated: boolean;
+}
+export declare const useAuthStore: import("pinia").StoreDefinition<"auth", AuthState, {
+    getUser: (state: AuthState) => User | null;
+    getToken: (state: AuthState) => string | null;
+    isLoggedIn: (state: AuthState) => boolean;
+    isHydrated: (state: AuthState) => boolean;
+}, {
+    setAuth({ user, token }: {
+        user: User;
+        token: string;
+    }): void;
+    loadAuth(): void;
+    logout(): void;
+    setHydrated(): void;
+}>;

package/dist/runtime/stores/auth.js

@@ -0,0 +1,59 @@
+import { defineStore } from "pinia";
+export const useAuthStore = defineStore("auth", {
+  state: () => ({
+    user: null,
+    token: null,
+    isAuthenticated: false,
+    _hydrated: false
+  }),
+  actions: {
+    setAuth({ user, token }) {
+      this.user = user;
+      this.token = token;
+      this.isAuthenticated = true;
+      if (process.client) {
+        localStorage.setItem("auth_token", token);
+        localStorage.setItem("auth_user", JSON.stringify(user));
+      }
+    },
+    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");
+      }
+    },
+    // Mark as hydrated without loading
+    setHydrated() {
+      this._hydrated = true;
+    }
+  },
+  getters: {
+    getUser: (state) => state.user,
+    getToken: (state) => state.token,
+    isLoggedIn: (state) => state.isAuthenticated,
+    isHydrated: (state) => state._hydrated
+  }
+});

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,10 @@
+import type { Country } from '../types/user.js';
+export declare const useCountriesStore: import("pinia").StoreDefinition<"countries", {
+    countries: Country[];
+    loading: boolean;
+    error: string | null;
+}, {}, {
+    setCountries(countries: Country[]): void;
+    setLoading(loading: boolean): void;
+    setError(error: string | null): void;
+}>;

package/dist/runtime/stores/countries.js

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

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;
+    }
+  }
+});