flowrix 1.0.1-beta.16 → 1.0.1-beta.160

package/dist/runtime/stores/product/README.md

@@ -89,22 +89,22 @@ await productStore.refreshProduct()
 const productStore = useProductSlugStore()
 
 // Check if product exists
-console.log(productStore.hasProduct)
+// console.log(productStore.hasProduct)
 
 // Get product name safely
-console.log(productStore.productName)
+// console.log(productStore.productName)
 
 // Check if product has discount
-console.log(productStore.hasDiscount)
+// console.log(productStore.hasDiscount)
 
 // Check loading state
-console.log(productStore.isProductLoading)
+// console.log(productStore.isProductLoading)
 
 // Get error message
-console.log(productStore.productError)
+// console.log(productStore.productError)
 
 // Check if product is valid
-console.log(productStore.isValidProduct)
+// console.log(productStore.isValidProduct)
 ```
 
 ## API Endpoint Format

package/dist/runtime/stores/product/slug.d.ts

@@ -155,23 +155,7 @@ export declare const useProductSlugStore: import("pinia").StoreDefinition<"produ
         lastFetchedSlug: string | null;
     } & import("pinia").PiniaCustomStateProperties<ProductSlugState>) => string | null | undefined;
 }, {
-    fetchProductBySlug(slug: string): Promise<{
-        [x: string]: any;
-        id?: string | number | undefined;
-        slug?: string | undefined;
-        name?: string | undefined;
-        description?: string | undefined;
-        price?: string | undefined;
-        rrp?: string | undefined;
-        pricefloat?: number | undefined;
-        rpfloat?: number | undefined;
-        brandimage?: string | undefined;
-        variations?: string | undefined;
-        template?: string | undefined;
-        images?: string[] | undefined;
-        category?: string | undefined;
-        stock?: number | undefined;
-    } | null>;
+    fetchProductBySlug(slug: string): Promise<any>;
     clearProduct(): void;
     clearError(): void;
     updateProduct(updates: Partial<Product>): void;

package/dist/runtime/stores/product.js

@@ -1,12 +1,18 @@
 import { defineStore } from "pinia";
-import { useApi } from "../utils/api.js";
+import { flowrixApi } from "../middleware/flowrix.js";
+import { useRuntimeConfig } from "#imports";
 export const useProduct = defineStore("Product", {
   state: () => ({
     data: {}
   }),
   actions: {
     async getProduct(slug, queryperameters = "") {
-      const { post } = useApi();
+      const config = useRuntimeConfig();
+      let rawCookies = "";
+      if (process.client) {
+        rawCookies = document.cookie || "";
+      }
+      const apiConfig = { ...config, cookies: rawCookies };
       try {
         let attributes = {};
         if (queryperameters.customize) {
@@ -24,7 +30,7 @@ export const useProduct = defineStore("Product", {
           attributes["fraction"] = fractions;
         }
         const apiUrl = `product/${slug}`;
-        const response = await post(apiUrl, attributes);
+        const response = await flowrixApi.post(apiUrl, apiConfig, { body: attributes });
         if (response.status === 200) {
           this.data = response.data.data;
         }

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

@@ -0,0 +1,51 @@
+export interface PromotionsState {
+    promotions: any;
+    loading: boolean;
+    error: string | null;
+    fetchPromise: Promise<void> | null;
+}
+export interface ApiResponse {
+    status?: string;
+    data?: any;
+    [key: string]: any;
+}
+export declare const usePromotions: import("pinia").StoreDefinition<"promotions", PromotionsState, {
+    hasPromotions: (state: {
+        promotions: any;
+        loading: boolean;
+        error: string | null;
+        fetchPromise: {
+            then: <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>;
+            catch: <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<void | TResult>;
+            finally: (onfinally?: (() => void) | null | undefined) => Promise<void>;
+            readonly [Symbol.toStringTag]: string;
+        } | null;
+    } & import("pinia").PiniaCustomStateProperties<PromotionsState>) => boolean;
+    isLoading: (state: {
+        promotions: any;
+        loading: boolean;
+        error: string | null;
+        fetchPromise: {
+            then: <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>;
+            catch: <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<void | TResult>;
+            finally: (onfinally?: (() => void) | null | undefined) => Promise<void>;
+            readonly [Symbol.toStringTag]: string;
+        } | null;
+    } & import("pinia").PiniaCustomStateProperties<PromotionsState>) => boolean;
+    hasError: (state: {
+        promotions: any;
+        loading: boolean;
+        error: string | null;
+        fetchPromise: {
+            then: <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>;
+            catch: <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<void | TResult>;
+            finally: (onfinally?: (() => void) | null | undefined) => Promise<void>;
+            readonly [Symbol.toStringTag]: string;
+        } | null;
+    } & import("pinia").PiniaCustomStateProperties<PromotionsState>) => boolean;
+}, {
+    fetchPromotions(force?: boolean): Promise<any>;
+    _doFetch(): Promise<void>;
+    refreshPromotions(): Promise<any>;
+    clearPromotions(): void;
+}>;

package/dist/runtime/stores/promotions.js

@@ -0,0 +1,65 @@
+import { defineStore } from "pinia";
+export const usePromotions = defineStore("promotions", {
+  state: () => ({
+    promotions: null,
+    loading: false,
+    error: null,
+    fetchPromise: null
+  }),
+  getters: {
+    hasPromotions: (state) => state.promotions !== null,
+    isLoading: (state) => state.loading,
+    hasError: (state) => state.error !== null
+  },
+  actions: {
+    async fetchPromotions(force = false) {
+      if (this.promotions && !force) {
+        return;
+      }
+      if (this.fetchPromise) {
+        return this.fetchPromise;
+      }
+      this.fetchPromise = this._doFetch();
+      try {
+        await this.fetchPromise;
+      } finally {
+        this.fetchPromise = null;
+      }
+    },
+    async _doFetch() {
+      this.loading = true;
+      this.error = null;
+      try {
+        const response = await $fetch("/api/global/promotions");
+        if (response.status === "Success" && response.data) {
+          this.promotions = response.data.data;
+        } else {
+          this.promotions = response.data;
+          this.error = null;
+        }
+      } catch (error) {
+        if (error.response) {
+          this.error = error.response.data.message || "An error occurred";
+          console.error(error.response);
+        } else {
+          this.error = "An error occurred";
+          console.error(error);
+        }
+        this.promotions = null;
+      } finally {
+        this.loading = false;
+      }
+    },
+    // Force refresh promotions (bypass cache)
+    async refreshPromotions() {
+      this.fetchPromise = null;
+      return this.fetchPromotions(true);
+    },
+    // Clear promotions cache
+    clearPromotions() {
+      this.promotions = null;
+      this.error = null;
+      this.fetchPromise = null;
+    }
+  }
+});

package/dist/runtime/stores/useCompanyProfile.js

@@ -10,10 +10,13 @@ export const useCompanyProfile = defineStore("company", {
       this.loading = true;
       this.error = null;
       try {
-        const data = await $fetch("/api/company/profile");
+        const data = await $fetch("/api/global/company_profile");
         this.profile = data;
       } catch (err) {
-        this.error = err;
+        this.error = {
+          message: err?.message,
+          statusCode: err?.statusCode
+        };
       } finally {
         this.loading = false;
       }

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

@@ -1,18 +1,33 @@
-export interface WebForm {
+export interface WebFormField {
     id: number;
+    name: string;
+    label: string;
+    type: string;
+    required: boolean;
+    options?: string[];
+    validation?: string;
+    placeholder?: string;
 }
-export interface WebFormData {
+export interface WebForm {
     id: number;
+    title: string;
+    description?: string;
+    fields: WebFormField[];
+    success_message?: string;
+}
+export interface WebFormSubmission {
+    [key: string]: any;
     recaptcha: string;
 }
+export interface WebFormResponse {
+    status: string;
+    message: string;
+    data: any | null;
+}
 export declare const useWebformsStore: import("pinia").StoreDefinition<"webforms", {
     webform: WebForm | null;
-    webFormReturn: any;
+    webFormReturn: WebFormResponse | null;
     loading: boolean;
     error: string | null;
-}, {}, {
-    setWebform(webform: WebForm | null): void;
-    setWebFormReturn(returnValue: any): void;
-    setLoading(loading: boolean): void;
-    setError(error: string | null): void;
-}>;
+    _hydrated: boolean;
+}, {}, {}>;

package/dist/runtime/stores/webforms.js

@@ -1,23 +1,123 @@
 import { defineStore } from "pinia";
+import { flowrixApi } from "../middleware/flowrix.js";
+import { useRuntimeConfig } from "#imports";
+function formatErrorMessage(message) {
+  if (typeof message === "string") {
+    return message;
+  }
+  if (Array.isArray(message)) {
+    return message.join(", ");
+  }
+  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 const useWebformsStore = defineStore("webforms", {
   state: () => ({
     webform: null,
     webFormReturn: null,
     loading: false,
-    error: null
+    error: null,
+    _hydrated: false
   }),
   actions: {
+    async fetchWebform(id) {
+      try {
+        this.loading = true;
+        this.error = null;
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = `contact-center/webforms/${id}/details`;
+        const response = await flowrixApi.get(apiUrl, apiConfig);
+        if (response.status === "Success" && response.data) {
+          this.webform = response.data;
+          return response.data;
+        }
+        return null;
+      } catch (error) {
+        console.error("Fetch webform failed:", error);
+        this.error = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to fetch webform";
+        return null;
+      } finally {
+        this.loading = false;
+      }
+    },
+    async submitInquiry(formData) {
+      try {
+        this.loading = true;
+        this.error = null;
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = "contact-center/webforms/create";
+        const response = await flowrixApi.post(apiUrl, apiConfig, {
+          body: formData
+        });
+        if (response.status === "Success") {
+          this.webFormReturn = response;
+          return response;
+        } else {
+          const errorMessage = response.message || "Failed to submit inquiry";
+          throw new Error(errorMessage);
+        }
+      } catch (error) {
+        console.error("Submit inquiry error:", error);
+        const message = error.data ? formatErrorMessage(error.data.message) : error.message || "Submission failed";
+        this.error = message;
+        return {
+          status: "Error",
+          message,
+          data: null
+        };
+      } finally {
+        this.loading = false;
+      }
+    },
     setWebform(webform) {
       this.webform = webform;
     },
     setWebFormReturn(returnValue) {
       this.webFormReturn = returnValue;
     },
-    setLoading(loading) {
-      this.loading = loading;
+    clearError() {
+      this.error = null;
+    },
+    clearWebFormReturn() {
+      this.webFormReturn = null;
     },
-    setError(error) {
-      this.error = error;
+    setHydrated() {
+      this._hydrated = true;
     }
+  },
+  getters: {
+    getWebform: (state) => state.webform,
+    getWebFormReturn: (state) => state.webFormReturn,
+    getLoading: (state) => state.loading,
+    getError: (state) => state.error,
+    isHydrated: (state) => state._hydrated
+  },
+  persist: {
+    enabled: true,
+    key: "webforms",
+    storage: typeof window !== "undefined" ? localStorage : void 0
   }
 });

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

@@ -1,28 +1,145 @@
 export interface Wishlist {
     id: number;
-    name?: string;
+    title: string;
+    default: boolean;
+    created_at: string;
 }
 export interface WishlistProduct {
     id: number;
-    productSlug: string;
+    slug: string;
+    item_id: string;
+    name: string;
+    image: string;
+    price: string;
+    pricefloat: number;
+    rp: string;
+    rpfloat: number;
+    type: string;
+    brandimage: string;
+    options?: any;
 }
 export interface WishlistProducts {
     [listId: number]: WishlistProduct[];
 }
+export interface CreateWishlistData {
+    title: string;
+    default: boolean;
+}
+export interface UpdateWishlistData {
+    title: string;
+    default: boolean;
+}
+export interface AddToWishlistData {
+}
+export interface ApiResponse<T> {
+    status: string;
+    message: string | Record<string, string[]> | null;
+    data: T | null;
+}
 export declare const useWishlistsStore: import("pinia").StoreDefinition<"wishlists", {
     wishlists: Wishlist[];
     wishlistProducts: WishlistProducts;
     loading: boolean;
     error: string | null;
-}, {}, {
+    productVersions: Record<number, number>;
+}, {
+    getWishlists: (state: {
+        wishlists: {
+            id: number;
+            title: string;
+            default: boolean;
+            created_at: string;
+        }[];
+        wishlistProducts: WishlistProducts;
+        loading: boolean;
+        error: string | null;
+        productVersions: Record<number, number>;
+    } & import("pinia").PiniaCustomStateProperties<{
+        wishlists: Wishlist[];
+        wishlistProducts: WishlistProducts;
+        loading: boolean;
+        error: string | null;
+        productVersions: Record<number, number>;
+    }>) => {
+        id: number;
+        title: string;
+        default: boolean;
+        created_at: string;
+    }[];
+    getWishlistProducts: (state: {
+        wishlists: {
+            id: number;
+            title: string;
+            default: boolean;
+            created_at: string;
+        }[];
+        wishlistProducts: WishlistProducts;
+        loading: boolean;
+        error: string | null;
+        productVersions: Record<number, number>;
+    } & import("pinia").PiniaCustomStateProperties<{
+        wishlists: Wishlist[];
+        wishlistProducts: WishlistProducts;
+        loading: boolean;
+        error: string | null;
+        productVersions: Record<number, number>;
+    }>) => (listId: number) => WishlistProduct[];
+    isLoading: (state: {
+        wishlists: {
+            id: number;
+            title: string;
+            default: boolean;
+            created_at: string;
+        }[];
+        wishlistProducts: WishlistProducts;
+        loading: boolean;
+        error: string | null;
+        productVersions: Record<number, number>;
+    } & import("pinia").PiniaCustomStateProperties<{
+        wishlists: Wishlist[];
+        wishlistProducts: WishlistProducts;
+        loading: boolean;
+        error: string | null;
+        productVersions: Record<number, number>;
+    }>) => boolean;
+    getError: (state: {
+        wishlists: {
+            id: number;
+            title: string;
+            default: boolean;
+            created_at: string;
+        }[];
+        wishlistProducts: WishlistProducts;
+        loading: boolean;
+        error: string | null;
+        productVersions: Record<number, number>;
+    } & import("pinia").PiniaCustomStateProperties<{
+        wishlists: Wishlist[];
+        wishlistProducts: WishlistProducts;
+        loading: boolean;
+        error: string | null;
+        productVersions: Record<number, number>;
+    }>) => string | null;
+}, {
+    setLoading(loading: boolean): void;
+    setError(error: string | null): void;
     setWishlists(wishlists: Wishlist[]): void;
     addWishlist(wishlist: Wishlist): void;
-    updateWishlist(updatedWishlist: Wishlist): void;
-    removeWishlist(id: number): void;
+    removeWishlist(wishlistId: number): void;
     setWishlistProducts(listId: number, products: WishlistProduct[]): void;
     addWishlistProduct(listId: number, product: WishlistProduct): void;
-    removeWishlistProduct(listId: number, productSlug: string): void;
     clearWishlistProducts(listId: number): void;
-    setLoading(loading: boolean): void;
-    setError(error: string | null): void;
+    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, itemId: number): Promise<ApiResponse<void>>;
+    updateWishlist(id: number, data: UpdateWishlistData): Promise<ApiResponse<Wishlist>>;
+    deleteWishlist(id: number): Promise<ApiResponse<void>>;
 }>;