flowrix 1.0.0

package/dist/runtime/composables/useDataLayer.js

@@ -0,0 +1,385 @@
+import { useCompanyProfile } from "../stores/useCompanyProfile.js";
+import { useCustomScript } from "./Product/CustomProduct/useCustomeScript.js";
+import { useProduct } from "../stores/product.js";
+const getDataLayer = () => {
+  if (process.client && typeof window !== "undefined" && window.dataLayer) {
+    return window.dataLayer;
+  }
+  return null;
+};
+const getCurrencyCode = () => {
+  const companyProfile = useCompanyProfile();
+  return companyProfile.profile?.currencyCode || "USD";
+};
+export function GTM_page_view(to) {
+  const dataLayer = getDataLayer();
+  if (dataLayer) {
+    dataLayer.push({
+      "event": "virtualPageView",
+      "virtualPagePath": to.fullPath,
+      "virtualPageTitle": to.meta?.head?.meta_title
+    });
+  }
+}
+export function GTM_view_item(product, price = 0, rp = 0) {
+  const dataLayer = getDataLayer();
+  if (!dataLayer || !product) return;
+  let discount = rp > price ? Number((rp - price).toFixed(2)) : 0;
+  dataLayer.push({
+    event: "view_item",
+    ecommerce: {
+      currency: getCurrencyCode(),
+      value: Number(price),
+      item_list_id: product?.slug,
+      item_list_name: product?.name,
+      items: [{
+        item_id: "SKU_" + product?.sku,
+        item_name: product?.name,
+        index: product?.id,
+        item_category: product?.category,
+        item_category2: product?.category,
+        item_list_id: product?.slug,
+        item_list_name: product?.name,
+        item_variant: "itemcolor",
+        price: Number(rp) > 0 ? Number(rp) : Number(price),
+        quantity: 1,
+        discount,
+        location_id: "online store"
+      }]
+    }
+  });
+}
+export function GTM_view_item_list(listItems = []) {
+  const dataLayer = getDataLayer();
+  if (!dataLayer) 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({
+        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: 1,
+        discount,
+        location_id: "online store"
+      });
+    });
+    dataLayer.push({
+      event: "view_item_list",
+      ecommerce: {
+        currency: getCurrencyCode(),
+        items: ecomarceItems
+      }
+    });
+  }
+}
+export function GTM_view_cart(cart = null) {
+  const dataLayer = getDataLayer();
+  if (!dataLayer || !cart?.items) return;
+  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"
+    };
+  });
+  dataLayer.push({
+    "event": "view_cart",
+    "ecommerce": {
+      currency: getCurrencyCode(),
+      value: cart.totals.total,
+      items: ecomarceCartItems
+    }
+  });
+}
+export function GTM_add_to_cart(lastitem = null) {
+  const dataLayer = getDataLayer();
+  if (!dataLayer || !lastitem) return;
+  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: "Color",
+    price,
+    quantity: 1,
+    discount,
+    location_id: "online store"
+  }];
+  dataLayer.push({
+    "event": "add_to_cart",
+    "ecommerce": {
+      currency: getCurrencyCode(),
+      value: lastitem?.pricefloat,
+      items: ecomarceCartItems
+    }
+  });
+}
+export function GTM_remove_from_cart(lastitem = null) {
+  const dataLayer = getDataLayer();
+  if (!dataLayer || !lastitem) return;
+  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"
+  }];
+  dataLayer.push({
+    "event": "remove_from_cart",
+    "ecommerce": {
+      currency: getCurrencyCode(),
+      value: lastitem?.pricefloat,
+      items: ecomarceCartItems
+    }
+  });
+}
+export function GTM_begin_checkout(cart = null) {
+  const dataLayer = getDataLayer();
+  if (!dataLayer || !cart?.items) return;
+  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"
+    };
+  });
+  dataLayer.push({
+    "event": "begin_checkout",
+    "ecommerce": {
+      currency: getCurrencyCode(),
+      value: cart.totals.total,
+      items: ecomarceCartItems
+    }
+  });
+}
+export function GTM_add_shipping_info(cart = null, shipping_tier = null) {
+  const dataLayer = getDataLayer();
+  if (!dataLayer || !cart?.items) return;
+  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 {
+      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"
+    };
+  });
+  dataLayer.push({
+    "event": "add_shipping_info",
+    "ecommerce": {
+      shipping_tier: shipping_tier?.title,
+      currency: getCurrencyCode(),
+      value: cart.totals.total,
+      items: ecomarceCartItems
+    }
+  });
+}
+export function GTM_add_payment_info(cart = null, payment_type = "") {
+  const dataLayer = getDataLayer();
+  if (!dataLayer || !cart?.items) return;
+  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"
+    };
+  });
+  dataLayer.push({
+    "event": "add_payment_info",
+    "ecommerce": {
+      payment_type,
+      currency: getCurrencyCode(),
+      value: cart.totals.total,
+      items: ecomarceCartItems
+    }
+  });
+}
+export function GTM_purchase(orderData = null, cart = null) {
+  const dataLayer = getDataLayer();
+  if (!dataLayer || !cart?.items || !orderData) return;
+  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"
+    };
+  });
+  dataLayer.push({
+    "event": "purchase",
+    "ecommerce": {
+      currency: getCurrencyCode(),
+      value: orderData.grandtotalFloat,
+      transaction_id: orderData.order_no,
+      affiliation: "online Store",
+      tax: orderData.tax,
+      shipping: orderData.shipping,
+      coupon: orderData.vouchercode,
+      items: purchaseitems
+    }
+  });
+}
+export function GTM_select_item_color(attribute, item = null, group = null) {
+  const dataLayer = getDataLayer();
+  if (!dataLayer || !attribute || !item) return;
+  const product = useProduct().data;
+  const customScript = useCustomScript();
+  let price = Number(customScript.productPrice);
+  let discount = Number(customScript.productDiscountedPrice) > price ? Number((Number(customScript.productDiscountedPrice) - price).toFixed(2)) : 0;
+  try {
+    const labelElement = document.querySelector(`label[for="attribute_${attribute.id}_value${item.parent}"]`);
+    const itemName = labelElement?.innerText || "";
+    dataLayer.push({
+      event: "select_item",
+      ecommerce: {
+        currency: getCurrencyCode(),
+        value: price,
+        items: [
+          {
+            item_id: itemName,
+            item_name: itemName,
+            affiliation: "Online Store",
+            coupon: "",
+            discount,
+            index: item.id,
+            item_brand: product?.brand,
+            item_category: product?.category,
+            item_list_id: itemName,
+            item_list_name: product?.name,
+            item_variant: item ? item.title : "",
+            location_id: "Online Store",
+            price: price + discount,
+            quantity: 1
+          }
+        ]
+      }
+    });
+  } catch (error) {
+    console.warn("GTM_select_item_color failed:", error);
+  }
+}
+export function GTM_select_item_collection(attribute, item = null, group = null) {
+  const dataLayer = getDataLayer();
+  if (!dataLayer || !attribute || !item) return;
+  const product = useProduct().data;
+  const customScript = useCustomScript();
+  let price = Number(customScript.productPrice);
+  let discount = Number(customScript.productDiscountedPrice) > price ? Number((Number(customScript.productDiscountedPrice) - price).toFixed(2)) : 0;
+  try {
+    const labelElement = document.querySelector(`label[for="attribute_${attribute.id}_value${item.parent}"]`);
+    const itemListId = labelElement?.innerText || "";
+    dataLayer.push({
+      event: "select_item",
+      ecommerce: {
+        currency: getCurrencyCode(),
+        value: price,
+        items: [
+          {
+            item_id: item.title,
+            item_name: item.title,
+            affiliation: "Online Store",
+            coupon: "",
+            discount,
+            index: item.id,
+            item_brand: product?.brand,
+            item_category: product?.category,
+            item_list_id: itemListId,
+            item_list_name: product?.name,
+            item_variant: "",
+            location_id: "Online Store",
+            price: price + discount,
+            quantity: 1
+          }
+        ]
+      }
+    });
+  } catch (error) {
+    console.warn("GTM_select_item_collection failed:", error);
+  }
+}
+export function GTM_Attribute_Content(content) {
+  const dataLayer = getDataLayer();
+  if (!dataLayer || !content) return;
+  dataLayer.push({
+    event: "view_content",
+    contentData: content
+  });
+}

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

@@ -0,0 +1,4 @@
+import type { VNode } from 'vue';
+export declare function useDynamicHtmlRenderer(html: string): Promise<VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>>;

package/dist/runtime/composables/useDynamicHtmlRenderer.js

@@ -0,0 +1,33 @@
+import { h } from "vue";
+const componentMap = {
+  // Components can be registered here as needed
+};
+export async function useDynamicHtmlRenderer(html) {
+  const { parseDocument } = await import("htmlparser2");
+  function convertNodeToVNode(node) {
+    if (node.type === "text") {
+      return node.data?.trim() ? node.data : null;
+    }
+    if (node.type === "tag") {
+      const tag = node.name.toLowerCase();
+      const props = {};
+      for (const [key, val] of Object.entries(node.attribs || {})) {
+        try {
+          props[key] = JSON.parse(val);
+        } catch {
+          props[key] = val;
+        }
+      }
+      const children2 = (node.children || []).map(convertNodeToVNode).filter(Boolean);
+      const component = componentMap[tag];
+      if (component) {
+        return h(component, { ...props, children: children2 });
+      }
+      return h(tag, props, children2);
+    }
+    return null;
+  }
+  const dom = parseDocument(html);
+  const children = dom.children.map(convertNodeToVNode).filter(Boolean);
+  return h("div", {}, children);
+}

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

@@ -0,0 +1,23 @@
+export interface LocationData {
+    country: string;
+    countryCode?: string;
+    state?: string;
+    city?: string;
+}
+export declare const useLocation: () => {
+    location: Readonly<import("vue").Ref<{
+        readonly country: string;
+        readonly countryCode?: string | undefined;
+        readonly state?: string | undefined;
+        readonly city?: string | undefined;
+    }, {
+        readonly country: string;
+        readonly countryCode?: string | undefined;
+        readonly state?: string | undefined;
+        readonly city?: string | undefined;
+    }>>;
+    shippingCountry: Readonly<import("vue").Ref<string, string>>;
+    updateLocation: (newLocation: Partial<LocationData>) => void;
+    updateCountry: (country: string, countryCode?: string) => void;
+    resetLocation: () => void;
+};

package/dist/runtime/composables/useLocation.js

@@ -0,0 +1,32 @@
+import { computed, readonly } from "vue";
+import { useCookie } from "#imports";
+export const useLocation = () => {
+  const locationCookie = useCookie("location", {
+    default: () => ({ country: "US" }),
+    // Default country
+    maxAge: 60 * 60 * 24 * 365,
+    // 1 year
+    sameSite: "lax"
+  });
+  const location = computed(() => locationCookie.value);
+  const updateLocation = (newLocation) => {
+    locationCookie.value = {
+      ...locationCookie.value,
+      ...newLocation
+    };
+  };
+  const updateCountry = (country, countryCode) => {
+    updateLocation({ country, countryCode });
+  };
+  const shippingCountry = computed(() => location.value.country);
+  const resetLocation = () => {
+    locationCookie.value = { country: "US" };
+  };
+  return {
+    location: readonly(location),
+    shippingCountry: readonly(shippingCountry),
+    updateLocation,
+    updateCountry,
+    resetLocation
+  };
+};

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

@@ -0,0 +1,12 @@
+import { type LocationData } from '../stores/locations.js';
+export interface ApiResponse<T> {
+    status: string;
+    message: string | Record<string, string[]> | null;
+    data: T | null;
+}
+export declare function useLocations(): {
+    fetchLocation: () => Promise<ApiResponse<LocationData>>;
+    location: import("vue").ComputedRef<LocationData | null>;
+    loading: import("vue").ComputedRef<boolean>;
+    error: import("vue").ComputedRef<string | null>;
+};

package/dist/runtime/composables/useLocations.js

@@ -0,0 +1,53 @@
+import { computed } from "vue";
+import { useLocationsStore } from "../stores/locations.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 useLocations() {
+  const store = useLocationsStore();
+  const { post } = useApi();
+  async function fetchLocation() {
+    if (store.location) {
+      return { status: "Success", message: null, data: store.location };
+    }
+    store.setLoading(true);
+    store.setError(null);
+    try {
+      const response = await post("/location", {});
+      if (response.status === "Success" && response.data) {
+        store.setLocation(response.data);
+        return response;
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        store.setError(errorMessage);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      console.error("Fetch location error:", error);
+      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to fetch location";
+      store.setError(errorMessage);
+      throw new Error(errorMessage);
+    } finally {
+      store.setLoading(false);
+    }
+  }
+  return {
+    fetchLocation,
+    location: computed(() => store.location),
+    loading: computed(() => store.loading),
+    error: computed(() => store.error)
+  };
+}

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

@@ -0,0 +1,10 @@
+export declare function META_page_view(to: any): void;
+export declare function META_view_item(product: any, price?: number, rp?: number): void;
+export declare function META_view_item_list(listItems?: any[]): void;
+export declare function META_add_to_cart(lastitem?: any): void;
+export declare function META_remove_from_cart(lastitem?: any): void;
+export declare function META_view_cart(cart?: any): void;
+export declare function META_begin_checkout(cart?: any): void;
+export declare function META_add_shipping_info(cart?: any, shipping_tier?: any): void;
+export declare function META_add_payment_info(cart?: any, payment_type?: string): void;
+export declare function META_purchase(orderData?: any, cart?: any): void;