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

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

@@ -0,0 +1,141 @@
+# Product Slug Store
+
+This store manages product data fetched by slug using Pinia for state management.
+
+## Usage Examples
+
+### Basic Usage in a Vue Component
+
+```vue
+<template>
+  <div>
+    <div v-if="productStore.isLoading">Loading product...</div>
+    <div v-else-if="productStore.error" class="error">
+      {{ productStore.error }}
+    </div>
+    <div v-else-if="productStore.hasProduct">
+      <h1>{{ productStore.product.name }}</h1>
+      <p>{{ productStore.product.description }}</p>
+      <div class="price">{{ productStore.product.price }}</div>
+      <div v-if="productStore.hasDiscount" class="discount">
+        Was: {{ productStore.product.rrp }}
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+const route = useRoute()
+const productStore = useProductSlugStore()
+
+// Fetch product on mount
+onMounted(async () => {
+  const slug = route.params.slug as string
+  if (slug) {
+    try {
+      await productStore.fetchProductBySlug(slug)
+    } catch (error) {
+      // Error is already handled in the store
+      console.error('Failed to load product')
+    }
+  }
+})
+</script>
+```
+
+### Using with Reactive References
+
+```vue
+<script setup lang="ts">
+const productStore = useProductSlugStore()
+
+// Use storeToRefs for reactive access
+const { product, isLoading, error, hasProduct } = storeToRefs(productStore)
+
+// Watch for route changes
+const route = useRoute()
+watch(() => route.params.slug, async (newSlug) => {
+  if (newSlug) {
+    await productStore.fetchProductBySlug(newSlug as string)
+  }
+}, { immediate: true })
+</script>
+```
+
+### Available Actions
+
+```typescript
+const productStore = useProductSlugStore()
+
+// Fetch product by slug
+await productStore.fetchProductBySlug('my-product-slug')
+
+// Clear product data
+productStore.clearProduct()
+
+// Clear error state
+productStore.clearError()
+
+// Update product (optimistic update)
+productStore.updateProduct({ name: 'Updated Name' })
+
+// Refresh current product
+await productStore.refreshProduct()
+```
+
+### Available Getters
+
+```typescript
+const productStore = useProductSlugStore()
+
+// Check if product exists
+console.log(productStore.hasProduct)
+
+// Get product name safely
+console.log(productStore.productName)
+
+// Check if product has discount
+console.log(productStore.hasDiscount)
+
+// Check loading state
+console.log(productStore.isProductLoading)
+
+// Get error message
+console.log(productStore.productError)
+
+// Check if product is valid
+console.log(productStore.isValidProduct)
+```
+
+## API Endpoint Format
+
+The store calls the API endpoint `/api/products/:slug` and expects it to return data in this format:
+
+```json
+{
+  "id": "123",
+  "slug": "product-slug",
+  "name": "Product Name",
+  "description": "Product description",
+  "price": "$99.99",
+  "rrp": "$129.99",
+  "pricefloat": 99.99,
+  "rpfloat": 129.99,
+  "brandimage": "/brand-logo.jpg",
+  "variations": "color,size",
+  "template": "simple",
+  "images": ["/image1.jpg", "/image2.jpg"],
+  "category": "electronics",
+  "stock": 10
+}
+```
+
+## Error Handling
+
+The store handles various error scenarios:
+- 404: Product not found
+- 500+: Server errors
+- Network errors
+- Invalid response format
+
+All errors are stored in the `error` state and can be accessed via the `productError` getter.

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

@@ -0,0 +1,165 @@
+interface Product {
+    id?: string | number;
+    slug?: string;
+    name?: string;
+    description?: string;
+    price?: string;
+    rrp?: string;
+    pricefloat?: number;
+    rpfloat?: number;
+    brandimage?: string;
+    variations?: string;
+    template?: string;
+    images?: string[];
+    category?: string;
+    stock?: number;
+    [key: string]: any;
+}
+interface ProductSlugState {
+    product: Product | null;
+    isLoading: boolean;
+    error: string | null;
+    lastFetchedSlug: string | null;
+}
+export declare const useProductSlugStore: import("pinia").StoreDefinition<"productSlug", ProductSlugState, {
+    hasProduct: (state: {
+        product: {
+            [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;
+        isLoading: boolean;
+        error: string | null;
+        lastFetchedSlug: string | null;
+    } & import("pinia").PiniaCustomStateProperties<ProductSlugState>) => boolean;
+    productName: (state: {
+        product: {
+            [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;
+        isLoading: boolean;
+        error: string | null;
+        lastFetchedSlug: string | null;
+    } & import("pinia").PiniaCustomStateProperties<ProductSlugState>) => string;
+    hasDiscount: (state: {
+        product: {
+            [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;
+        isLoading: boolean;
+        error: string | null;
+        lastFetchedSlug: string | null;
+    } & import("pinia").PiniaCustomStateProperties<ProductSlugState>) => boolean | 0 | undefined;
+    isProductLoading: (state: {
+        product: {
+            [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;
+        isLoading: boolean;
+        error: string | null;
+        lastFetchedSlug: string | null;
+    } & import("pinia").PiniaCustomStateProperties<ProductSlugState>) => boolean;
+    productError: (state: {
+        product: {
+            [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;
+        isLoading: boolean;
+        error: string | null;
+        lastFetchedSlug: string | null;
+    } & import("pinia").PiniaCustomStateProperties<ProductSlugState>) => string | null;
+    isValidProduct: (state: {
+        product: {
+            [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;
+        isLoading: boolean;
+        error: string | null;
+        lastFetchedSlug: string | null;
+    } & import("pinia").PiniaCustomStateProperties<ProductSlugState>) => string | null | undefined;
+}, {
+    fetchProductBySlug(slug: string): Promise<any>;
+    clearProduct(): void;
+    clearError(): void;
+    updateProduct(updates: Partial<Product>): void;
+    setLoading(loading: boolean): void;
+    refreshProduct(): Promise<void>;
+}>;
+export {};

package/dist/runtime/stores/product/slug.js

@@ -0,0 +1,91 @@
+import { defineStore } from "pinia";
+export const useProductSlugStore = defineStore("productSlug", {
+  state: () => ({
+    product: null,
+    isLoading: false,
+    error: null,
+    lastFetchedSlug: null
+  }),
+  getters: {
+    // Check if product is currently loaded
+    hasProduct: (state) => state.product !== null,
+    // Get product name safely
+    productName: (state) => state.product?.name || "",
+    // Check if product has discount
+    hasDiscount: (state) => {
+      if (!state.product) return false;
+      return state.product.rpfloat && state.product.pricefloat && state.product.rpfloat > state.product.pricefloat;
+    },
+    // Get loading state
+    isProductLoading: (state) => state.isLoading,
+    // Get error state
+    productError: (state) => state.error,
+    // Check if we have a valid product with required fields
+    isValidProduct: (state) => {
+      return state.product && state.product.name && state.product.slug;
+    }
+  },
+  actions: {
+    // Fetch product by slug
+    async fetchProductBySlug(slug) {
+      if (this.isLoading && this.lastFetchedSlug === slug) {
+        return this.product;
+      }
+      if (this.product?.slug === slug && !this.error) {
+        return this.product;
+      }
+      this.isLoading = true;
+      this.error = null;
+      this.lastFetchedSlug = slug;
+      try {
+        const response = await $fetch(`/api/${slug}`);
+        if (response) {
+          this.product = response;
+          this.error = null;
+        } else {
+          throw new Error("Product not found");
+        }
+        return this.product;
+      } catch (error) {
+        if (error.statusCode === 404) {
+          this.error = "Product not found";
+        } else if (error.statusCode >= 500) {
+          this.error = "Server error. Please try again later.";
+        } else {
+          this.error = error?.data?.message || error?.message || "Failed to fetch product";
+        }
+        this.product = null;
+        console.error("Error fetching product:", error);
+        throw error;
+      } finally {
+        this.isLoading = false;
+      }
+    },
+    // Clear product data
+    clearProduct() {
+      this.product = null;
+      this.error = null;
+      this.lastFetchedSlug = null;
+    },
+    // Reset error state
+    clearError() {
+      this.error = null;
+    },
+    // Update product data (useful for optimistic updates)
+    updateProduct(updates) {
+      if (this.product) {
+        this.product = { ...this.product, ...updates };
+      }
+    },
+    // Set loading state manually (useful for external loading indicators)
+    setLoading(loading) {
+      this.isLoading = loading;
+    },
+    // Refresh current product
+    async refreshProduct() {
+      if (this.lastFetchedSlug) {
+        await this.fetchProductBySlug(this.lastFetchedSlug);
+      }
+    }
+  }
+});

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

@@ -0,0 +1,5 @@
+export declare const useProduct: import("pinia").StoreDefinition<"Product", {
+    data: {};
+}, {}, {
+    getProduct(slug: any, queryperameters?: string): Promise<void>;
+}>;

package/dist/runtime/stores/product.js

@@ -0,0 +1,38 @@
+import { defineStore } from "pinia";
+import { useApi } from "../utils/api.js";
+export const useProduct = defineStore("Product", {
+  state: () => ({
+    data: {}
+  }),
+  actions: {
+    async getProduct(slug, queryperameters = "") {
+      const { post } = useApi();
+      try {
+        let attributes = {};
+        if (queryperameters.customize) {
+          if (useCartStore().cart.items[queryperameters.customize] != void 0) {
+            const getItem = useCartStore().cart.items[queryperameters.customize].options.ids;
+            const fractions = useCartStore().cart.items[queryperameters.customize].options.fraction;
+            attributes["attribute_id"] = getItem;
+            attributes["fraction"] = fractions;
+          }
+        }
+        if (queryperameters.wishlist != void 0) {
+          const getItem = JSON.parse(queryperameters.ids);
+          const fractions = JSON.parse(queryperameters.fractions);
+          attributes["attribute_id"] = getItem;
+          attributes["fraction"] = fractions;
+        }
+        const apiUrl = `product/${slug}`;
+        const response = await post(apiUrl, attributes);
+        if (response.status === 200) {
+          this.data = response.data.data;
+        }
+      } catch (error) {
+        if (error.response) {
+          this.data = null;
+        }
+      }
+    }
+  }
+});

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

@@ -0,0 +1,12 @@
+export interface Quotation {
+    id: number;
+}
+export declare const useQuotationsStore: import("pinia").StoreDefinition<"quotations", {
+    quotations: Quotation[];
+    loading: boolean;
+    error: string | null;
+}, {}, {
+    setQuotations(quotations: Quotation[]): void;
+    setLoading(loading: boolean): void;
+    setError(error: string | null): void;
+}>;

package/dist/runtime/stores/quotations.js

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

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

@@ -0,0 +1,11 @@
+export interface SubscriptionResponse {
+}
+export declare const useSubscriptionsStore: import("pinia").StoreDefinition<"subscriptions", {
+    response: any;
+    error: string | null;
+    loading: boolean;
+}, {}, {
+    setResponse(response: any): void;
+    setError(error: string | null): void;
+    setLoading(loading: boolean): void;
+}>;

package/dist/runtime/stores/subscriptions.js

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

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

@@ -0,0 +1,7 @@
+export declare const useCompanyProfile: import("pinia").StoreDefinition<"company", {
+    profile: null;
+    loading: boolean;
+    error: null;
+}, {}, {
+    fetchProfile(): Promise<void>;
+}>;

package/dist/runtime/stores/useCompanyProfile.js

@@ -0,0 +1,22 @@
+import { defineStore } from "pinia";
+export const useCompanyProfile = defineStore("company", {
+  state: () => ({
+    profile: null,
+    loading: false,
+    error: null
+  }),
+  actions: {
+    async fetchProfile() {
+      this.loading = true;
+      this.error = null;
+      try {
+        const data = await $fetch("/api/company/profile");
+        this.profile = data;
+      } catch (err) {
+        this.error = err;
+      } finally {
+        this.loading = false;
+      }
+    }
+  }
+});

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

@@ -0,0 +1,5 @@
+export declare const useNavMenuStore: import("pinia").StoreDefinition<"NavMenu", {
+    Menu: {};
+}, {}, {
+    navMenu(id: number, location?: string): Promise<void>;
+}>;

package/dist/runtime/stores/useNavMenuStore.js

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

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

@@ -0,0 +1,18 @@
+export interface WebForm {
+    id: number;
+}
+export interface WebFormData {
+    id: number;
+    recaptcha: string;
+}
+export declare const useWebformsStore: import("pinia").StoreDefinition<"webforms", {
+    webform: WebForm | null;
+    webFormReturn: any;
+    loading: boolean;
+    error: string | null;
+}, {}, {
+    setWebform(webform: WebForm | null): void;
+    setWebFormReturn(returnValue: any): void;
+    setLoading(loading: boolean): void;
+    setError(error: string | null): void;
+}>;

package/dist/runtime/stores/webforms.js

@@ -0,0 +1,23 @@
+import { defineStore } from "pinia";
+export const useWebformsStore = defineStore("webforms", {
+  state: () => ({
+    webform: null,
+    webFormReturn: null,
+    loading: false,
+    error: null
+  }),
+  actions: {
+    setWebform(webform) {
+      this.webform = webform;
+    },
+    setWebFormReturn(returnValue) {
+      this.webFormReturn = returnValue;
+    },
+    setLoading(loading) {
+      this.loading = loading;
+    },
+    setError(error) {
+      this.error = error;
+    }
+  }
+});