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

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

@@ -5,19 +5,19 @@ export declare const useClientApi: () => {
     put: <T>(url: string, data: any, options?: FetchOptions, extraHeaders?: Record<string, string>) => Promise<T>;
     delete: <T>(url: string, options?: FetchOptions, extraHeaders?: Record<string, string>) => Promise<T>;
     withShippingCountry: (country: string) => {
-        get: <T>(url: string, options?: FetchOptions) => Promise<T>;
-        post: <T>(url: string, data: any, options?: FetchOptions) => Promise<T>;
-        put: <T>(url: string, data: any, options?: FetchOptions) => Promise<T>;
-        delete: <T>(url: string, options?: FetchOptions) => Promise<T>;
+        get: <T>(url: string, options?: FetchOptions) => Promise<any>;
+        post: <T>(url: string, data: any, options?: FetchOptions) => Promise<any>;
+        put: <T>(url: string, data: any, options?: FetchOptions) => Promise<any>;
+        delete: <T>(url: string, options?: FetchOptions) => Promise<any>;
     };
     withLocation: (location: {
         country?: string;
         region?: string;
         zipcode?: string;
     }) => {
-        get: <T>(url: string, options?: FetchOptions) => Promise<T>;
-        post: <T>(url: string, data: any, options?: FetchOptions) => Promise<T>;
-        put: <T>(url: string, data: any, options?: FetchOptions) => Promise<T>;
-        delete: <T>(url: string, options?: FetchOptions) => Promise<T>;
+        get: <T>(url: string, options?: FetchOptions) => Promise<any>;
+        post: <T>(url: string, data: any, options?: FetchOptions) => Promise<any>;
+        put: <T>(url: string, data: any, options?: FetchOptions) => Promise<any>;
+        delete: <T>(url: string, options?: FetchOptions) => Promise<any>;
     };
 };

package/dist/runtime/composables/useClientApi.js

@@ -1,52 +1,96 @@
-import { useApi } from "../utils/api.js";
+import { flowrixApi } from "../middleware/flowrix.js";
+import { useRuntimeConfig } from "#imports";
 export const useClientApi = () => {
-  const api = useApi();
+  const config = useRuntimeConfig();
+  const getApiConfig = () => {
+    let rawCookies = "";
+    if (process.client) {
+      rawCookies = document.cookie || "";
+    }
+    return { ...config, cookies: rawCookies };
+  };
   const clientApi = {
     // GET request with automatic location headers
     get: async (url, options = {}, extraHeaders = {}) => {
-      return await api.get(url, options, extraHeaders);
+      const apiConfig = getApiConfig();
+      const mergedOptions = { ...options, headers: { ...options.headers, ...extraHeaders } };
+      return await flowrixApi.get(url, apiConfig, mergedOptions);
     },
     // POST request with automatic location headers
     post: async (url, data, options = {}, extraHeaders = {}) => {
-      return await api.post(url, data, options, extraHeaders);
+      const apiConfig = getApiConfig();
+      const mergedOptions = { body: data, ...options, headers: { ...options.headers, ...extraHeaders } };
+      return await flowrixApi.post(url, apiConfig, mergedOptions);
     },
     // PUT request with automatic location headers
     put: async (url, data, options = {}, extraHeaders = {}) => {
-      return await api.put(url, data, options, extraHeaders);
+      const apiConfig = getApiConfig();
+      const mergedOptions = { body: data, ...options, headers: { ...options.headers, ...extraHeaders } };
+      return await flowrixApi.put(url, apiConfig, mergedOptions);
     },
     // DELETE request with automatic location headers
     delete: async (url, options = {}, extraHeaders = {}) => {
-      return await api.delete(url, options, extraHeaders);
+      const apiConfig = getApiConfig();
+      const mergedOptions = { ...options, headers: { ...options.headers, ...extraHeaders } };
+      return await flowrixApi.delete(url, apiConfig, mergedOptions);
     },
     // Convenience method for requests with custom shipping country
     withShippingCountry: (country) => ({
-      get: (url, options = {}) => api.get(url, options, { "shipping-country": country }),
-      post: (url, data, options = {}) => api.post(url, data, options, { "shipping-country": country }),
-      put: (url, data, options = {}) => api.put(url, data, options, { "shipping-country": country }),
-      delete: (url, options = {}) => api.delete(url, options, { "shipping-country": country })
+      get: (url, options = {}) => {
+        const apiConfig = getApiConfig();
+        return flowrixApi.get(url, apiConfig, { ...options, headers: { ...options.headers, "shipping-country": country } });
+      },
+      post: (url, data, options = {}) => {
+        const apiConfig = getApiConfig();
+        return flowrixApi.post(url, apiConfig, { body: data, ...options, headers: { ...options.headers, "shipping-country": country } });
+      },
+      put: (url, data, options = {}) => {
+        const apiConfig = getApiConfig();
+        return flowrixApi.put(url, apiConfig, { body: data, ...options, headers: { ...options.headers, "shipping-country": country } });
+      },
+      delete: (url, options = {}) => {
+        const apiConfig = getApiConfig();
+        return flowrixApi.delete(url, apiConfig, { ...options, headers: { ...options.headers, "shipping-country": country } });
+      }
     }),
     // Convenience method for requests with custom location
     withLocation: (location) => ({
-      get: (url, options = {}) => api.get(url, options, {
-        ...location.country && { "shipping-country": location.country },
-        ...location.region && { "shipping-region": location.region },
-        ...location.zipcode && { "shipping-zipcode": location.zipcode }
-      }),
-      post: (url, data, options = {}) => api.post(url, data, options, {
-        ...location.country && { "shipping-country": location.country },
-        ...location.region && { "shipping-region": location.region },
-        ...location.zipcode && { "shipping-zipcode": location.zipcode }
-      }),
-      put: (url, data, options = {}) => api.put(url, data, options, {
-        ...location.country && { "shipping-country": location.country },
-        ...location.region && { "shipping-region": location.region },
-        ...location.zipcode && { "shipping-zipcode": location.zipcode }
-      }),
-      delete: (url, options = {}) => api.delete(url, options, {
-        ...location.country && { "shipping-country": location.country },
-        ...location.region && { "shipping-region": location.region },
-        ...location.zipcode && { "shipping-zipcode": location.zipcode }
-      })
+      get: (url, options = {}) => {
+        const apiConfig = getApiConfig();
+        const locationHeaders = {
+          ...location.country && { "shipping-country": location.country },
+          ...location.region && { "shipping-region": location.region },
+          ...location.zipcode && { "shipping-zipcode": location.zipcode }
+        };
+        return flowrixApi.get(url, apiConfig, { ...options, headers: { ...options.headers, ...locationHeaders } });
+      },
+      post: (url, data, options = {}) => {
+        const apiConfig = getApiConfig();
+        const locationHeaders = {
+          ...location.country && { "shipping-country": location.country },
+          ...location.region && { "shipping-region": location.region },
+          ...location.zipcode && { "shipping-zipcode": location.zipcode }
+        };
+        return flowrixApi.post(url, apiConfig, { body: data, ...options, headers: { ...options.headers, ...locationHeaders } });
+      },
+      put: (url, data, options = {}) => {
+        const apiConfig = getApiConfig();
+        const locationHeaders = {
+          ...location.country && { "shipping-country": location.country },
+          ...location.region && { "shipping-region": location.region },
+          ...location.zipcode && { "shipping-zipcode": location.zipcode }
+        };
+        return flowrixApi.put(url, apiConfig, { body: data, ...options, headers: { ...options.headers, ...locationHeaders } });
+      },
+      delete: (url, options = {}) => {
+        const apiConfig = getApiConfig();
+        const locationHeaders = {
+          ...location.country && { "shipping-country": location.country },
+          ...location.region && { "shipping-region": location.region },
+          ...location.zipcode && { "shipping-zipcode": location.zipcode }
+        };
+        return flowrixApi.delete(url, apiConfig, { ...options, headers: { ...options.headers, ...locationHeaders } });
+      }
     })
   };
   return clientApi;

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

@@ -0,0 +1,48 @@
+/**
+ * GDPR Compliant Cookie Consent Composable
+ * Custom implementation - no external libraries
+ *
+ * Categories:
+ * - necessary: Always enabled, required for website functionality
+ * - functional: Improve user experience
+ * - analytics: Help understand website traffic
+ * - marketing: Used for advertising
+ */
+export interface CookiePreferences {
+    necessary: boolean;
+    functional: boolean;
+    analytics: boolean;
+    marketing: boolean;
+    timestamp: string;
+}
+export interface PendingScript {
+    src?: string;
+    innerHTML?: string;
+    category: 'functional' | 'analytics' | 'marketing';
+    id?: string;
+}
+declare global {
+    interface Window {
+        dataLayer: any[];
+        cookieConsentPreferences: CookiePreferences | null;
+        pendingScripts: PendingScript[];
+    }
+}
+export declare const useCookieConsent: () => {
+    getConsent: () => CookiePreferences | null;
+    hasConsentChoice: () => boolean;
+    hasConsent: (category: "necessary" | "functional" | "analytics" | "marketing") => boolean;
+    saveConsent: (preferences: Omit<CookiePreferences, "necessary" | "timestamp">) => void;
+    acceptAll: () => void;
+    rejectNonEssential: () => void;
+    savePreferences: (preferences: Omit<CookiePreferences, "necessary" | "timestamp">) => void;
+    clearConsent: () => void;
+    initializeDefaultConsent: () => void;
+    updateGoogleConsent: (consent: CookiePreferences) => void;
+    pushConsentEvent: (action: string, preferences: Omit<CookiePreferences, "necessary" | "timestamp">) => void;
+    registerScript: (script: PendingScript) => void;
+    loadScript: (script: PendingScript) => void;
+    activatePendingScripts: (consent: CookiePreferences) => void;
+    loadExistingConsent: () => boolean;
+    deleteNonEssentialCookies: () => void;
+};

package/dist/runtime/composables/useCookieConsent.js

@@ -0,0 +1,185 @@
+const CONSENT_KEY = "cookie_consent";
+export const useCookieConsent = () => {
+  const getConsent = () => {
+    if (typeof window === "undefined") return null;
+    const stored = localStorage.getItem(CONSENT_KEY);
+    if (!stored) return null;
+    try {
+      return JSON.parse(stored);
+    } catch {
+      return null;
+    }
+  };
+  const hasConsentChoice = () => {
+    if (typeof window === "undefined") return false;
+    return localStorage.getItem(CONSENT_KEY) !== null;
+  };
+  const hasConsent = (category) => {
+    if (category === "necessary") return true;
+    const consent = getConsent();
+    if (!consent) return false;
+    return consent[category] === true;
+  };
+  const saveConsent = (preferences) => {
+    if (typeof window === "undefined") return;
+    const consent = {
+      necessary: true,
+      // Always true
+      functional: preferences.functional,
+      analytics: preferences.analytics,
+      marketing: preferences.marketing,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    localStorage.setItem(CONSENT_KEY, JSON.stringify(consent));
+    window.cookieConsentPreferences = consent;
+    updateGoogleConsent(consent);
+    activatePendingScripts(consent);
+  };
+  const acceptAll = () => {
+    saveConsent({
+      functional: true,
+      analytics: true,
+      marketing: true
+    });
+    pushConsentEvent("accept_all", { functional: true, analytics: true, marketing: true });
+  };
+  const rejectNonEssential = () => {
+    saveConsent({
+      functional: false,
+      analytics: false,
+      marketing: false
+    });
+    pushConsentEvent("reject_non_essential", { functional: false, analytics: false, marketing: false });
+  };
+  const savePreferences = (preferences) => {
+    saveConsent(preferences);
+    pushConsentEvent("save_preferences", preferences);
+  };
+  const clearConsent = () => {
+    if (typeof window === "undefined") return;
+    localStorage.removeItem(CONSENT_KEY);
+    window.cookieConsentPreferences = null;
+  };
+  const initializeDefaultConsent = () => {
+    if (typeof window === "undefined") return;
+    window.dataLayer = window.dataLayer || [];
+    window.pendingScripts = window.pendingScripts || [];
+    window.dataLayer.push({
+      "event": "consent_default",
+      "consent": {
+        "ad_storage": "denied",
+        "ad_user_data": "denied",
+        "ad_personalization": "denied",
+        "analytics_storage": "denied",
+        "functionality_storage": "denied",
+        "personalization_storage": "denied",
+        "security_storage": "granted"
+      }
+    });
+  };
+  const updateGoogleConsent = (consent) => {
+    if (typeof window === "undefined") return;
+    window.dataLayer = window.dataLayer || [];
+    window.dataLayer.push({
+      "event": "consent_update",
+      "consent": {
+        "ad_storage": consent.marketing ? "granted" : "denied",
+        "ad_user_data": consent.marketing ? "granted" : "denied",
+        "ad_personalization": consent.marketing ? "granted" : "denied",
+        "analytics_storage": consent.analytics ? "granted" : "denied",
+        "functionality_storage": consent.functional ? "granted" : "denied",
+        "personalization_storage": consent.functional ? "granted" : "denied",
+        "security_storage": "granted"
+      }
+    });
+  };
+  const pushConsentEvent = (action, preferences) => {
+    if (typeof window === "undefined") return;
+    window.dataLayer = window.dataLayer || [];
+    window.dataLayer.push({
+      "event": "cookie_consent_action",
+      "action": action,
+      "functional": preferences.functional,
+      "analytics": preferences.analytics,
+      "marketing": preferences.marketing
+    });
+  };
+  const registerScript = (script) => {
+    if (typeof window === "undefined") return;
+    window.pendingScripts = window.pendingScripts || [];
+    const consent = getConsent();
+    if (consent && consent[script.category]) {
+      loadScript(script);
+    } else {
+      window.pendingScripts.push(script);
+    }
+  };
+  const loadScript = (script) => {
+    if (typeof window === "undefined") return;
+    if (script.id && document.getElementById(script.id)) return;
+    const scriptEl = document.createElement("script");
+    if (script.id) scriptEl.id = script.id;
+    if (script.src) {
+      scriptEl.src = script.src;
+      scriptEl.async = true;
+    }
+    if (script.innerHTML) {
+      scriptEl.innerHTML = script.innerHTML;
+    }
+    document.head.appendChild(scriptEl);
+  };
+  const activatePendingScripts = (consent) => {
+    if (typeof window === "undefined") return;
+    const pending = window.pendingScripts || [];
+    const remaining = [];
+    pending.forEach((script) => {
+      if (consent[script.category]) {
+        loadScript(script);
+      } else {
+        remaining.push(script);
+      }
+    });
+    window.pendingScripts = remaining;
+  };
+  const loadExistingConsent = () => {
+    if (typeof window === "undefined") return false;
+    const consent = getConsent();
+    if (consent) {
+      window.cookieConsentPreferences = consent;
+      updateGoogleConsent(consent);
+      activatePendingScripts(consent);
+      return true;
+    }
+    return false;
+  };
+  const deleteNonEssentialCookies = () => {
+    if (typeof window === "undefined") return;
+    const cookies = document.cookie.split(";");
+    const essentialCookies = ["cookie_consent", "PHPSESSID", "csrf_token", "session"];
+    cookies.forEach((cookie) => {
+      const cookieName = cookie.split("=")[0].trim();
+      if (!essentialCookies.some((essential) => cookieName.includes(essential))) {
+        document.cookie = `${cookieName}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;`;
+        document.cookie = `${cookieName}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/; domain=${window.location.hostname};`;
+      }
+    });
+  };
+  return {
+    getConsent,
+    hasConsentChoice,
+    hasConsent,
+    saveConsent,
+    acceptAll,
+    rejectNonEssential,
+    savePreferences,
+    clearConsent,
+    initializeDefaultConsent,
+    updateGoogleConsent,
+    pushConsentEvent,
+    registerScript,
+    loadScript,
+    activatePendingScripts,
+    loadExistingConsent,
+    deleteNonEssentialCookies
+  };
+};

package/dist/runtime/composables/useDataLayer.js

@@ -9,7 +9,7 @@ const getDataLayer = () => {
 };
 const getCurrencyCode = () => {
   const companyProfile = useCompanyProfile();
-  return companyProfile.profile?.currencyCode || "USD";
+  return companyProfile.profile?.data?.currencyCode || "USD";
 };
 export function GTM_page_view(to) {
   const dataLayer = getDataLayer();

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

@@ -0,0 +1,3 @@
+export declare function addtodotdigital(email: any): void;
+export declare function sendCartInsight(): void;
+export declare function CompleteCartInsight(cart: any, status: any): void;

package/dist/runtime/composables/useDotDigital.js

@@ -0,0 +1,122 @@
+import { useCartStore } from "../stores/Cart.js";
+import { useAuthStore } from "../stores/auth.js";
+import { useRouter } from "vue-router";
+const cartStore = useCartStore();
+const authStore = useAuthStore();
+const router = useRouter();
+const getUTCDateTime = () => {
+  const now = /* @__PURE__ */ new Date();
+  const pad = (number) => number < 10 ? `0${number}` : number;
+  const year = now.getUTCFullYear();
+  const month = pad(now.getUTCMonth() + 1);
+  const day = pad(now.getUTCDate());
+  const hours = pad(now.getUTCHours());
+  const minutes = pad(now.getUTCMinutes());
+  const seconds = pad(now.getUTCSeconds());
+  return `${year}${month}${day}T${hours}${minutes}${seconds}Z`;
+};
+const generateProductUrl = (sku) => {
+  const resolvedRoute = router.resolve({ name: "Product", params: { slug: sku } });
+  return window.location.origin + resolvedRoute.href;
+};
+const generateCartUrl = (token) => {
+  const resolvedRoute = router.resolve({ name: "AbandonedCart", params: { slug: token } });
+  return "https://" + window.location.host + resolvedRoute.href;
+};
+export function addtodotdigital(email) {
+  if (typeof window.dmPt !== "undefined" && window.dmPt) {
+    window.dmPt("identify", email);
+  }
+}
+export function sendCartInsight() {
+  if (typeof window.dmPt !== "undefined" && window.dmPt) {
+    const cartItems = cartStore.cart.items;
+    const totals = cartStore.cart.totals;
+    const abndToken = cartStore.cart.abndToken;
+    const isAuthenticated = authStore.isAuthenticated;
+    const cartPhase = isAuthenticated ? "CUSTOMER_LOGIN" : "Guest";
+    if (isAuthenticated) {
+      window.dmPt("identify", authStore.user.email);
+    }
+    let lineItems = [];
+    if (cartItems) {
+      Object.values(cartItems).forEach((item, index) => {
+        lineItems.push({
+          sku: item.sku,
+          name: item.name,
+          description: item.name,
+          category: item.category,
+          unitPrice: item.rpfloat,
+          salePrice: item.pricefloat,
+          quantity: item.qty,
+          totalPrice: Number(item.qty * item.pricefloat),
+          imageUrl: item.image,
+          productUrl: generateProductUrl(item.slug)
+        });
+      });
+    }
+    const cartData = {
+      programID: 33188,
+      cartDelay: 1,
+      cartID: abndToken,
+      cartPhase: "CART",
+      currency: "AUD",
+      subtotal: totals.subtotal,
+      discountAmount: totals.discount,
+      createDate: getUTCDateTime(),
+      modifiedDate: getUTCDateTime(),
+      taxAmount: totals.gst,
+      shipping: totals.shipping,
+      grandTotal: totals.total,
+      cartUrl: generateCartUrl(abndToken),
+      lineItems
+    };
+    window.dmPt("cartInsight", cartData);
+  }
+}
+export function CompleteCartInsight(cart, status) {
+  if (typeof window.dmPt !== "undefined" && window.dmPt) {
+    const cartItems = cart.items;
+    const totals = cart.totals;
+    const abndToken = cart.abndToken;
+    const isAuthenticated = authStore.isAuthenticated;
+    const cartPhase = isAuthenticated ? "CUSTOMER_LOGIN" : "Guest";
+    if (isAuthenticated == true) {
+      dmPt("identify", authStore.user.email);
+    }
+    let lineItems = [];
+    if (cartItems) {
+      Object.values(cartItems).forEach((item, index) => {
+        lineItems.push({
+          sku: item.sku,
+          name: item.name,
+          description: item.name,
+          category: item.category,
+          unitPrice: item.rpfloat,
+          salePrice: item.pricefloat,
+          quantity: item.qty,
+          totalPrice: Number(item.qty * item.pricefloat),
+          imageUrl: item.image,
+          productUrl: generateProductUrl(item.slug)
+        });
+      });
+    }
+    const cartData = {
+      programID: 33188,
+      cartDelay: 1,
+      cartID: abndToken,
+      cartPhase: status,
+      currency: "AUD",
+      subtotal: totals.subtotal,
+      discountAmount: totals.discount,
+      createDate: getUTCDateTime(),
+      modifiedDate: getUTCDateTime(),
+      taxAmount: totals.gst,
+      shipping: totals.shipping,
+      grandTotal: totals.total,
+      cartUrl: generateCartUrl(abndToken),
+      lineItems
+    };
+    window.dmPt("cartInsight", cartData);
+  }
+}

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

@@ -1,23 +1,53 @@
-export interface LocationData {
+interface LocationInputs {
     country: string;
-    countryCode?: string;
-    state?: string;
+    country_id: string | number;
+    zip_code: string | number;
+    region: string;
+    region_id: string | number | null;
+}
+interface LocationData {
     city?: string;
+    country_name?: string;
+    country_code?: string;
+    country_id?: number;
+    ip?: string;
+    proxy?: boolean;
+    region?: string;
+    region_short?: string;
+    region_id?: number;
+    zip_code?: 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;
+export declare function useLocation(defaultLocation: any): {
+    states: import("vue").Ref<never[], never[]>;
+    manualLocationHeading: import("vue").Ref<string | null, string | null>;
+    locationInputs: import("vue").Ref<{
+        country: string;
+        country_id: string | number;
+        zip_code: string | number;
+        region: string;
+        region_id: string | number | null;
+    }, LocationInputs | {
+        country: string;
+        country_id: string | number;
+        zip_code: string | number;
+        region: string;
+        region_id: string | number | null;
+    }>;
+    location: import("vue").ComputedRef<any>;
+    countries: import("vue").ComputedRef<any>;
+    loading: import("vue").ComputedRef<any>;
+    companyCountryId: import("vue").ComputedRef<any>;
+    getStates: (countryId: number | string) => any;
+    changeStates: (selectedCountry: string | number) => void;
+    changeLocation: (data?: Partial<LocationInputs>) => Promise<void>;
+    updateLocationData: (data?: Partial<LocationInputs>) => Promise<void>;
+    getLocation: (skipBrowserRequest?: boolean) => Promise<void>;
+    checkCurrentLocation: () => void;
+    initLocationInputs: () => void;
+    loadLocation: () => LocationData | null;
+    checkLocationPermission: () => Promise<string>;
+    initializeCountriesAndStates: () => Promise<void>;
+    requestBrowserLocation: () => Promise<boolean>;
+    openLocationModal: () => void;
 };
+export {};