flowrix 1.0.0

package/dist/runtime/composables/useMetaLayer.js

@@ -0,0 +1,263 @@
+import { useCompanyProfile } from "../stores/useCompanyProfile.js";
+const getFbq = () => {
+  if (process.client && typeof window !== "undefined" && window.fbq) {
+    return window.fbq;
+  }
+  return null;
+};
+export function META_page_view(to) {
+  const fbq = getFbq();
+  if (fbq) {
+    fbq("trackCustom", "virtualPageView", {
+      content_type: "virtualPageView",
+      content_name: to.meta?.head?.meta_title,
+      currency: useCompanyProfile().profile?.currencyCode
+    });
+  }
+}
+export function META_view_item(product, price = 0, rp = 0) {
+  const fbq = getFbq();
+  if (fbq) {
+    let discount = rp > price ? Number((rp - price).toFixed(2)) : 0;
+    fbq("track", "ViewContent", {
+      content_ids: [product.sku],
+      content_type: "product",
+      content_name: product.name,
+      discount,
+      value: price,
+      currency: useCompanyProfile().profile?.currencyCode
+    });
+  }
+}
+export function META_view_item_list(listItems = []) {
+  try {
+    const fbq = getFbq();
+    if (!fbq) return;
+    const ecomarceItems = [];
+    if (listItems && listItems.length > 0) {
+      listItems.forEach((item) => {
+        const price = item.pricefloat;
+        const discount = item.rpfloat > item.pricefloat ? Number((item.rpfloat - item.pricefloat).toFixed(2)) : 0;
+        ecomarceItems.push({
+          id: item.id,
+          sku: "SKU_" + item.sku,
+          item_name: item.name,
+          index: item.id,
+          item_category: item.category,
+          item_category2: item.category,
+          item_list_id: item.slug,
+          item_list_name: item.name,
+          item_variant: "itemcolor",
+          price,
+          quantity: 1,
+          discount,
+          location_id: "online store"
+        });
+      });
+      fbq("track", "view_item_list", {
+        contents: ecomarceItems,
+        content_type: "Items List",
+        value: 0,
+        currency: useCompanyProfile().profile?.currencyCode || "GBP"
+      });
+    }
+  } catch (err) {
+    console.warn("META_view_item_list failed:", err);
+  }
+}
+export function META_add_to_cart(lastitem = null) {
+  const fbq = getFbq();
+  if (fbq && lastitem) {
+    let discount = lastitem.rpfloat > lastitem.pricefloat ? Number((lastitem.rpfloat - lastitem.pricefloat).toFixed(2)) : 0;
+    fbq("track", "AddToCart", {
+      content_ids: [lastitem.sku],
+      content_type: "product",
+      content_name: lastitem.name,
+      discount,
+      value: lastitem.pricefloat,
+      currency: useCompanyProfile().profile?.currencyCode
+    });
+  }
+}
+export function META_remove_from_cart(lastitem = null) {
+  const fbq = getFbq();
+  if (fbq && lastitem) {
+    let price = lastitem.pricefloat;
+    let discount = lastitem.rpfloat > lastitem.pricefloat ? Number((lastitem.rpfloat - lastitem.pricefloat).toFixed(2)) : 0;
+    const ecomarceCartItems = [{
+      item_id: "SKU_" + lastitem.sku,
+      item_name: lastitem.name,
+      index: lastitem.id,
+      item_category: lastitem.category,
+      item_category2: lastitem.category,
+      item_list_id: lastitem.slug,
+      item_list_name: lastitem.name,
+      item_variant: "itemcolor",
+      price,
+      quantity: lastitem.qty,
+      discount,
+      location_id: "online store"
+    }];
+    fbq("track", "remove_from_cart", {
+      contents: ecomarceCartItems,
+      content_type: "Items List",
+      value: lastitem?.pricefloat,
+      currency: useCompanyProfile().profile?.currencyCode
+    });
+  }
+}
+export function META_view_cart(cart = null) {
+  const fbq = getFbq();
+  if (fbq && cart?.items) {
+    const ecomarceCartItems = Object.values(cart.items).map((item) => {
+      let price = item.pricefloat;
+      let discount = item.rpfloat > item.pricefloat ? Number((item.rpfloat - item.pricefloat).toFixed(2)) : 0;
+      return {
+        id: item.id,
+        sku: "SKU_" + item.sku,
+        item_name: item.name,
+        index: item.id,
+        item_category: item.category,
+        item_category2: item.category,
+        item_list_id: item.slug,
+        item_list_name: item.name,
+        item_variant: "itemcolor",
+        price,
+        quantity: item.qty,
+        discount,
+        location_id: "online store"
+      };
+    });
+    fbq("track", "view_cart", {
+      contents: ecomarceCartItems,
+      content_type: "View Cart",
+      value: cart.totals.total,
+      currency: useCompanyProfile().profile?.currencyCode
+    });
+  }
+}
+export function META_begin_checkout(cart = null) {
+  const fbq = getFbq();
+  if (fbq && cart?.items) {
+    const ecomarceCartItems = Object.values(cart.items).map((item) => {
+      let price = item.pricefloat;
+      let discount = item.rpfloat > item.pricefloat ? Number((item.rpfloat - item.pricefloat).toFixed(2)) : 0;
+      return {
+        item_id: "SKU_" + item.sku,
+        item_name: item.name,
+        index: item.id,
+        item_category: item.category,
+        item_category2: item.category,
+        item_list_id: item.slug,
+        item_list_name: item.name,
+        item_variant: "itemcolor",
+        price,
+        quantity: item.qty,
+        discount,
+        location_id: "online store"
+      };
+    });
+    fbq("trackCustom", "begin_checkout", {
+      contents: ecomarceCartItems,
+      content_type: "Checkout",
+      value: cart.totals.total,
+      currency: useCompanyProfile().profile?.currencyCode
+    });
+  }
+}
+export function META_add_shipping_info(cart = null, shipping_tier = null) {
+  const fbq = getFbq();
+  if (fbq && cart?.items) {
+    if (shipping_tier) {
+      shipping_tier.price = cart.totals.shipping;
+    }
+    const ecomarceCartItems = Object.values(cart.items).map((item) => {
+      let price = item.pricefloat;
+      let discount = item.rpfloat > item.pricefloat ? Number((item.rpfloat - item.pricefloat).toFixed(2)) : 0;
+      return {
+        id: item.id,
+        item_id: "SKU_" + item.sku,
+        item_name: item.name,
+        index: item.id,
+        item_category: item.category,
+        item_category2: item.category,
+        item_list_id: item.slug,
+        item_list_name: item.name,
+        item_variant: "itemcolor",
+        price,
+        quantity: item.qty,
+        discount,
+        location_id: "online store"
+      };
+    });
+    fbq("trackCustom", "add_shipping_info", {
+      contents: ecomarceCartItems,
+      content_type: shipping_tier?.title || "Shipping",
+      value: cart.totals.total,
+      currency: useCompanyProfile().profile?.currencyCode
+    });
+  }
+}
+export function META_add_payment_info(cart = null, payment_type = "") {
+  const fbq = getFbq();
+  if (fbq && cart?.items) {
+    const ecomarceCartItems = Object.values(cart.items).map((item) => {
+      let price = item.pricefloat;
+      let discount = item.rpfloat > item.pricefloat ? Number((item.rpfloat - item.pricefloat).toFixed(2)) : 0;
+      return {
+        item_id: "SKU_" + item.sku,
+        item_name: item.name,
+        index: item.id,
+        item_category: item.category,
+        item_category2: item.category,
+        item_list_id: item.slug,
+        item_list_name: item.name,
+        item_variant: "itemcolor",
+        price,
+        quantity: item.qty,
+        discount,
+        location_id: "online store"
+      };
+    });
+    fbq("trackCustom", "add_payment_info", {
+      contents: ecomarceCartItems,
+      content_type: payment_type || "Payment",
+      value: cart.totals.total,
+      currency: useCompanyProfile().profile?.currencyCode
+    });
+  }
+}
+export function META_purchase(orderData = null, cart = null) {
+  const fbq = getFbq();
+  if (fbq && cart?.items) {
+    const purchaseitems = Object.values(cart.items).map((item) => {
+      let price = item.pricefloat;
+      let discount = item.rpfloat > item.pricefloat ? Number((item.rpfloat - item.pricefloat).toFixed(2)) : 0;
+      return {
+        item_id: "SKU_" + item.sku,
+        item_name: item.name,
+        index: item.id,
+        item_category: item.category,
+        item_category2: item.category,
+        item_list_id: item.slug,
+        item_list_name: item.name,
+        item_variant: "itemcolor",
+        price,
+        quantity: item.qty,
+        discount,
+        location_id: "online store"
+      };
+    });
+    fbq("track", "Purchase", {
+      contents: purchaseitems,
+      content_type: "Product",
+      value: orderData.grandtotalFloat,
+      transaction_id: orderData.order_no,
+      affiliation: "online Store",
+      tax: orderData.tax,
+      shipping: orderData.shipping,
+      coupon: orderData.vouchercode,
+      currency: useCompanyProfile().profile?.currencyCode
+    });
+  }
+}

package/dist/runtime/composables/useOrders.d.ts

@@ -0,0 +1,21 @@
+import { type Order } from '../stores/orders.js';
+export interface ApiResponse<T> {
+    status: string;
+    message: string | Record<string, string[]> | null;
+    data: T | null;
+}
+export declare function useOrders(): {
+    fetchOrders: () => Promise<ApiResponse<Order[]>>;
+    downloadInvoice: (orderNo: string) => Promise<void>;
+    orders: import("vue").ComputedRef<{
+        id: number;
+        order_no: string;
+        order_status: string;
+        payment_method: string;
+        grandtotal: number;
+    }[]>;
+    loading: import("vue").ComputedRef<boolean>;
+    error: import("vue").ComputedRef<string | null>;
+    loadingInvoice: import("vue").ComputedRef<string | null>;
+    downloadError: import("vue").ComputedRef<string | null>;
+};

package/dist/runtime/composables/useOrders.js

@@ -0,0 +1,82 @@
+import { ref, computed } from "vue";
+import { useOrdersStore } from "../stores/orders.js";
+import { useApi } from "../utils/api.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 useOrders() {
+  const store = useOrdersStore();
+  const { get } = useApi();
+  const loadingInvoice = ref(null);
+  const error = ref(null);
+  async function fetchOrders() {
+    store.setLoading(true);
+    store.setError(null);
+    try {
+      const response = await get("/customer/orders");
+      if (response.status === "Success" && response.data) {
+        store.setOrders(response.data);
+        return response;
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        store.setError(errorMessage);
+        throw new Error(errorMessage);
+      }
+    } catch (error2) {
+      console.error("Fetch orders error:", error2);
+      const errorMessage = error2.data ? formatErrorMessage(error2.data.message) : error2.message || "Failed to fetch orders";
+      store.setError(errorMessage);
+      throw new Error(errorMessage);
+    } finally {
+      store.setLoading(false);
+    }
+  }
+  async function downloadInvoice(orderNo) {
+    loadingInvoice.value = orderNo;
+    error.value = null;
+    try {
+      const response = await get(`customer/orders/${orderNo}/tax-invoice`, {
+        params: { orderNo },
+        responseType: "blob"
+      });
+      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;
+    } catch (err) {
+      console.error("Download invoice error:", err);
+      const errorMessage = err.data ? formatErrorMessage(err.data.message) : err.message || "Failed to download invoice";
+      error.value = errorMessage;
+      throw new Error(errorMessage);
+    } finally {
+      loadingInvoice.value = null;
+    }
+  }
+  return {
+    fetchOrders,
+    downloadInvoice,
+    orders: computed(() => store.orders),
+    loading: computed(() => store.loading),
+    error: computed(() => store.error),
+    loadingInvoice: computed(() => loadingInvoice.value),
+    downloadError: computed(() => error.value)
+  };
+}

package/dist/runtime/composables/useQuotations.d.ts

@@ -0,0 +1,14 @@
+import { type Quotation } from '../stores/quotations.js';
+export interface ApiResponse<T> {
+    status: string;
+    message: string | Record<string, string[]> | null;
+    data: T | null;
+}
+export declare function useQuotations(): {
+    fetchQuotations: () => Promise<ApiResponse<Quotation[]>>;
+    quotations: import("vue").ComputedRef<{
+        id: number;
+    }[]>;
+    loading: import("vue").ComputedRef<boolean>;
+    error: import("vue").ComputedRef<string | null>;
+};

package/dist/runtime/composables/useQuotations.js

@@ -0,0 +1,50 @@
+import { computed } from "vue";
+import { useQuotationsStore } from "../stores/quotations.js";
+import { useApi } from "../utils/api.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 useQuotations() {
+  const store = useQuotationsStore();
+  const { get } = useApi();
+  async function fetchQuotations() {
+    store.setLoading(true);
+    store.setError(null);
+    try {
+      const response = await get("/customer/quotations");
+      if (response.status === "Success" && response.data) {
+        store.setQuotations(response.data);
+        return response;
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        store.setError(errorMessage);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      console.error("Fetch quotations error:", error);
+      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to fetch quotations";
+      store.setError(errorMessage);
+      throw new Error(errorMessage);
+    } finally {
+      store.setLoading(false);
+    }
+  }
+  return {
+    fetchQuotations,
+    quotations: computed(() => store.quotations),
+    loading: computed(() => store.loading),
+    error: computed(() => store.error)
+  };
+}

package/dist/runtime/composables/useSearch.d.ts

@@ -0,0 +1,7 @@
+export declare function useSearch(): {
+    searchQuery: import("vue").Ref<string, string>;
+    data: import("vue").ComputedRef<any[]>;
+    loading: import("vue").Ref<boolean, boolean>;
+    error: import("vue").Ref<Error | null, Error | null>;
+    fetchSearchData: (query: string) => Promise<void>;
+};

package/dist/runtime/composables/useSearch.js

@@ -0,0 +1,40 @@
+import { ref, computed, watch, onMounted } from "vue";
+import { useRoute } from "#imports";
+import { useSearchStore } from "../stores/search";
+export function useSearch() {
+  const route = useRoute();
+  const searchStore = useSearchStore();
+  const searchQuery = ref(route.query.search || "");
+  const loading = ref(false);
+  const error = ref(null);
+  const fetchSearchData = async (query) => {
+    if (!query) return;
+    loading.value = true;
+    error.value = null;
+    try {
+      await searchStore.fetchSearchData(query);
+    } catch (err) {
+      console.error("Search failed:", err);
+      error.value = err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  watch(
+    () => route.query.search,
+    (newVal) => {
+      searchQuery.value = newVal;
+      fetchSearchData(searchQuery.value);
+    }
+  );
+  onMounted(() => {
+    if (searchQuery.value) fetchSearchData(searchQuery.value);
+  });
+  return {
+    searchQuery,
+    data: computed(() => searchStore.data),
+    loading,
+    error,
+    fetchSearchData
+  };
+}

package/dist/runtime/composables/useSubscriptions.d.ts

@@ -0,0 +1,13 @@
+export interface ApiResponse<T> {
+    status: string;
+    message: string | Record<string, string[]> | null;
+    data: T | null;
+}
+export declare function useSubscriptions(): {
+    subscribe: (email: string) => Promise<ApiResponse<any>>;
+    response: import("vue").ComputedRef<any>;
+    error: import("vue").ComputedRef<string | null>;
+    loading: import("vue").ComputedRef<boolean>;
+    clearResponse: () => void;
+    clearError: () => void;
+};

package/dist/runtime/composables/useSubscriptions.js

@@ -0,0 +1,58 @@
+import { computed } from "vue";
+import { useSubscriptionsStore } from "../stores/subscriptions.js";
+import { useApi } from "../utils/api.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 useSubscriptions() {
+  const store = useSubscriptionsStore();
+  const { post } = useApi();
+  async function subscribe(email) {
+    store.setLoading(true);
+    store.setError(null);
+    try {
+      const response = await post("/subscribe", { email });
+      if (response.status === "Success") {
+        store.setResponse(response);
+        return response;
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        store.setError(errorMessage);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      console.error("Subscribe error:", error);
+      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to subscribe";
+      store.setError(errorMessage);
+      throw new Error(errorMessage);
+    } finally {
+      store.setLoading(false);
+    }
+  }
+  function clearResponse() {
+    store.setResponse(null);
+  }
+  function clearError() {
+    store.setError(null);
+  }
+  return {
+    subscribe,
+    response: computed(() => store.response),
+    error: computed(() => store.error),
+    loading: computed(() => store.loading),
+    clearResponse,
+    clearError
+  };
+}

package/dist/runtime/composables/useTikTokDatalayer.d.ts

@@ -0,0 +1,8 @@
+export declare function TikTok_page_view(to: any): void;
+export declare function TikTok_view_item(product: any, price?: number, rp?: number): void;
+export declare function TikTok_add_to_cart(lastitem?: any): void;
+export declare function TikTok_view_cart(cart?: any): void;
+export declare function TikTok_remove_from_cart(lastitem?: any): void;
+export declare function TikTok_begin_checkout(cart?: any): void;
+export declare function TikTok_add_payment_info(cart?: any, payment_type?: string): void;
+export declare function TikTok_purchase(orderData?: any, cart?: any): void;