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

package/dist/runtime/composables/useQuotationCheckout.js

@@ -0,0 +1,137 @@
+import { ref } from "vue";
+export const useQuotationCheckout = () => {
+  const publishableKey = ref({});
+  const responseData = ref([]);
+  const QuotationData = ref([]);
+  const checkoutSession = ref([]);
+  const preference = ref({ data: { fields: {} } });
+  const errorResponseData = ref([]);
+  const inputData = ref({
+    paymentmethod: "",
+    customertoken: "",
+    authoritytoleave: void 0,
+    register: "",
+    password: "",
+    password_confirmation: "",
+    passwordStrengthValue: "",
+    customernotes: "",
+    ewayKey: "",
+    eway_cardname: "",
+    eway_cardnumber: "",
+    eway_expirymonth: "",
+    eway_expiryyear: "",
+    eway_cvn: "",
+    till_cardname: "",
+    till_cardnumber: "",
+    till_cvn: "",
+    till_expirymonth: "",
+    till_expiryyear: "",
+    save_card_details: 0
+  });
+  const resetState = () => {
+    publishableKey.value = {};
+    responseData.value = [];
+    checkoutSession.value = [];
+    preference.value = [];
+    errorResponseData.value = [];
+  };
+  const getQuotation = async (slug) => {
+    try {
+      const response = await $fetch(`/api/checkout/quotation/${slug}`, {
+        method: "GET"
+      });
+      if (response) {
+        publishableKey.value = response.data;
+        QuotationData.value = response;
+      }
+      return response;
+    } catch (error) {
+      errorResponseData.value = error.data || error;
+      throw error;
+    }
+  };
+  const getGuestQuotation = async (slug, query) => {
+    try {
+      const response = await $fetch(`/api/checkout/quotation/guest/${slug}`, {
+        method: "GET",
+        query
+      });
+      if (response) {
+        publishableKey.value = response.data;
+        QuotationData.value = response;
+        responseData.value = response;
+      }
+      return response;
+    } catch (error) {
+      errorResponseData.value = error.data || error;
+      throw error;
+    }
+  };
+  const GuestCheckoutQuotation = async (slug, quotationData, query) => {
+    try {
+      responseData.value = [];
+      errorResponseData.value = [];
+      const FormData = quotationData.fields;
+      const response = await $fetch(`/api/checkout/quotation/guest/${slug}`, {
+        method: "POST",
+        body: FormData,
+        query
+      });
+      if (response) {
+        publishableKey.value = response.data;
+        responseData.value = response;
+      }
+      return response;
+    } catch (error) {
+      errorResponseData.value = error.data || error;
+      throw error;
+    }
+  };
+  const paymentMethods = async (formData) => {
+    try {
+      const response = await $fetch("/api/checkout/paymentmethod", {
+        method: "POST",
+        body: formData
+      });
+      if (response) {
+        publishableKey.value = response.data;
+      }
+      return response;
+    } catch (error) {
+      errorResponseData.value = error.data || error;
+      throw error;
+    }
+  };
+  const submitCheckout = async (slug, quotationData) => {
+    try {
+      responseData.value = [];
+      errorResponseData.value = [];
+      const response = await $fetch(`/api/checkout/quotation/submit/${slug}`, {
+        method: "POST",
+        body: quotationData
+      });
+      if (response.status == "Success") {
+        responseData.value = response.data;
+      }
+      return response;
+    } catch (error) {
+      errorResponseData.value = error.data || error;
+      throw error;
+    }
+  };
+  return {
+    inputData,
+    publishableKey,
+    responseData,
+    QuotationData,
+    checkoutSession,
+    preference,
+    errorResponseData,
+    resetState,
+    getQuotation,
+    getGuestQuotation,
+    GuestCheckoutQuotation,
+    paymentMethods,
+    submitCheckout
+  };
+};

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

@@ -1,13 +1,20 @@
-export interface ApiResponse<T> {
-    status: string;
-    message: string | Record<string, string[]> | null;
-    data: T | null;
+export interface SubscribeResponse {
+    status: 'Success' | 'Error';
+    message: string;
+    data?: any;
 }
 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;
+    loading: import("vue").Ref<boolean, boolean>;
+    response: import("vue").Ref<{
+        status: "Success" | "Error";
+        message: string;
+        data?: any;
+    } | null, SubscribeResponse | {
+        status: "Success" | "Error";
+        message: string;
+        data?: any;
+    } | null>;
+    error: import("vue").Ref<string | null, string | null>;
+    subscribe: (email: string) => Promise<SubscribeResponse>;
+    clear: () => void;
 };

package/dist/runtime/composables/useSubscriptions.js

@@ -1,6 +1,6 @@
-import { computed } from "vue";
-import { useSubscriptionsStore } from "../stores/subscriptions.js";
-import { useApi } from "../utils/api.js";
+import { ref } from "vue";
+import { flowrixApi } from "../middleware/flowrix.js";
+import { useRuntimeConfig } from "#imports";
 function formatErrorMessage(message) {
   if (!message) return "An error occurred";
   if (typeof message === "string") {
@@ -17,42 +17,77 @@ function formatErrorMessage(message) {
   return errorMessages.join(", ");
 }
 export function useSubscriptions() {
-  const store = useSubscriptionsStore();
-  const { post } = useApi();
-  async function subscribe(email) {
-    store.setLoading(true);
-    store.setError(null);
+  const loading = ref(false);
+  const response = ref(null);
+  const error = ref(null);
+  const subscribe = async (email) => {
+    loading.value = true;
+    response.value = null;
+    error.value = null;
     try {
-      const response = await post("/subscribe", { email });
-      if (response.status === "Success") {
-        store.setResponse(response);
-        return response;
+      const config = useRuntimeConfig();
+      let rawCookies = "";
+      if (process.client) {
+        rawCookies = document.cookie || "";
+      }
+      const apiConfig = {
+        ...config,
+        cookies: rawCookies
+      };
+      const apiResponse = await flowrixApi.post("subscribe", apiConfig, {
+        body: { email }
+      });
+      if (apiResponse.status === "Success") {
+        const successResponse = {
+          status: "Success",
+          message: apiResponse.message || "Successfully subscribed!",
+          data: apiResponse.data
+        };
+        response.value = successResponse;
+        return successResponse;
       } else {
-        const errorMessage = formatErrorMessage(response.message);
-        store.setError(errorMessage);
-        throw new Error(errorMessage);
+        const errorMessage = formatErrorMessage(apiResponse.message);
+        const errorResponse = {
+          status: "Error",
+          message: errorMessage,
+          data: apiResponse.data
+        };
+        error.value = errorMessage;
+        response.value = errorResponse;
+        return errorResponse;
+      }
+    } catch (apiError) {
+      console.error("Subscribe error:", apiError);
+      let errorMessage = "Failed to subscribe";
+      if (apiError.data?.message) {
+        errorMessage = formatErrorMessage(apiError.data.message);
+      } else if (apiError.message) {
+        errorMessage = apiError.message;
       }
-    } 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);
+      const errorResponse = {
+        status: "Error",
+        message: errorMessage,
+        data: apiError.data || null
+      };
+      error.value = errorMessage;
+      response.value = errorResponse;
+      return errorResponse;
     } finally {
-      store.setLoading(false);
+      loading.value = false;
     }
-  }
-  function clearResponse() {
-    store.setResponse(null);
-  }
-  function clearError() {
-    store.setError(null);
-  }
+  };
+  const clear = () => {
+    loading.value = false;
+    response.value = null;
+    error.value = null;
+  };
   return {
+    // State
+    loading,
+    response,
+    error,
+    // Methods
     subscribe,
-    response: computed(() => store.response),
-    error: computed(() => store.error),
-    loading: computed(() => store.loading),
-    clearResponse,
-    clearError
+    clear
   };
 }

package/dist/runtime/composables/useTikTokDatalayer.js

@@ -24,7 +24,7 @@ export function TikTok_view_item(product, price = 0, rp = 0) {
       description: product?.category,
       content_name: product?.name,
       price: Number(rp) > 0 ? Number(rp) : Number(price),
-      currency: useCompanyProfile().profile?.currencyCode,
+      currency: useCompanyProfile().profile?.data?.currencyCode,
       value: price
     }]
   });
@@ -46,7 +46,7 @@ export function TikTok_add_to_cart(lastitem = "") {
   ttq.track("AddToCart", {
     contents: ecomarceCartItems,
     value: price,
-    currency: useCompanyProfile().profile?.currencyCode
+    currency: useCompanyProfile().profile?.data?.currencyCode
   });
 }
 export function TikTok_view_cart(cart = "") {
@@ -68,7 +68,7 @@ export function TikTok_view_cart(cart = "") {
   ttq.track("ViewCart", {
     contents: ecomarceCartItems,
     value: cart.totals.total,
-    currency: useCompanyProfile().profile?.currencyCode
+    currency: useCompanyProfile().profile?.data?.currencyCode
   });
 }
 export function TikTok_remove_from_cart(lastitem = "") {
@@ -88,7 +88,7 @@ export function TikTok_remove_from_cart(lastitem = "") {
   ttq.track("RemoveFromCart", {
     contents: ecomarceCartItems,
     value: price,
-    currency: useCompanyProfile().profile?.currencyCode
+    currency: useCompanyProfile().profile?.data?.currencyCode
   });
 }
 export function TikTok_begin_checkout(cart = "") {
@@ -110,7 +110,7 @@ export function TikTok_begin_checkout(cart = "") {
   ttq.track("InitiateCheckout", {
     contents: ecomarceCartItems,
     value: cart.totals.total,
-    currency: useCompanyProfile().profile?.currencyCode
+    currency: useCompanyProfile().profile?.data?.currencyCode
   });
 }
 export function TikTok_add_payment_info(cart = "", payment_type = "") {
@@ -133,7 +133,7 @@ export function TikTok_add_payment_info(cart = "", payment_type = "") {
     contents: ecomarceCartItems,
     payment_type,
     value: cart.totals.total,
-    currency: useCompanyProfile().profile?.currencyCode
+    currency: useCompanyProfile().profile?.data?.currencyCode
   });
 }
 export function TikTok_purchase(orderData = "", cart = "") {
@@ -155,7 +155,7 @@ export function TikTok_purchase(orderData = "", cart = "") {
   ttq.track("Purchase", {
     contents: purchaseitems,
     value: orderData.grandtotalFloat,
-    currency: useCompanyProfile().profile?.currencyCode,
+    currency: useCompanyProfile().profile?.data?.currencyCode,
     transaction_id: orderData.order_no,
     affiliation: "online Store",
     tax: orderData.tax,

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

@@ -1,16 +1,45 @@
-import { type WebForm, type WebFormData } from '../stores/webforms.js';
-export interface ApiResponse<T> {
-    status: string;
-    message: string | Record<string, string[]> | null;
-    data: T | null;
-}
+import type { WebForm, WebFormSubmission, WebFormResponse } from '../stores/webforms.js';
 export declare function useWebforms(): {
-    fetchWebform: (id: number) => Promise<ApiResponse<WebForm>>;
-    submitInquiry: (formData: WebFormData, recaptchaToken?: string) => Promise<ApiResponse<any>>;
+    showSuccessModal: import("vue").Ref<boolean, boolean>;
+    currentFormData: import("vue").Ref<{
+        [x: string]: any;
+        recaptcha: string;
+    } | null, WebFormSubmission | {
+        [x: string]: any;
+        recaptcha: string;
+    } | null>;
+    recaptchaToken: import("vue").Ref<string, string>;
+    formLoading: import("vue").Ref<boolean, boolean>;
     webform: import("vue").ComputedRef<{
         id: number;
+        title: string;
+        description?: string | undefined;
+        fields: {
+            id: number;
+            name: string;
+            label: string;
+            type: string;
+            required: boolean;
+            options?: string[] | undefined;
+            validation?: string | undefined;
+            placeholder?: string | undefined;
+        }[];
+        success_message?: string | undefined;
+    } | null>;
+    webFormReturn: import("vue").ComputedRef<{
+        status: string;
+        message: string;
+        data: any | null;
     } | null>;
-    webFormReturn: import("vue").ComputedRef<any>;
     loading: import("vue").ComputedRef<boolean>;
     error: import("vue").ComputedRef<string | null>;
+    clearMessages: () => void;
+    fetchWebform: (id: number) => Promise<WebForm | null>;
+    initFormSubmission: (formData: WebFormSubmission) => void;
+    submitInquiry: (formData: WebFormSubmission) => Promise<WebFormResponse>;
+    setRecaptchaToken: (token: string) => void;
+    closeSuccessModal: () => void;
+    resetForm: () => void;
+    autoClearMessages: () => void;
+    isFormValid: (formData: WebFormSubmission) => boolean;
 };

package/dist/runtime/composables/useWebforms.js

@@ -1,75 +1,108 @@
-import { computed } from "vue";
+import { ref, computed } from "vue";
 import { useWebformsStore } from "../stores/webforms.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 useWebforms() {
-  const store = useWebformsStore();
-  const { get, post } = useApi();
-  async function fetchWebform(id) {
-    store.setLoading(true);
-    store.setError(null);
+  const webformsStore = useWebformsStore();
+  const showSuccessModal = ref(false);
+  const currentFormData = ref(null);
+  const recaptchaToken = ref("");
+  const formLoading = ref(false);
+  const webform = computed(() => webformsStore.webform);
+  const webFormReturn = computed(() => webformsStore.webFormReturn);
+  const loading = computed(() => webformsStore.loading);
+  const error = computed(() => webformsStore.error);
+  const clearMessages = () => {
+    webformsStore.clearWebFormReturn();
+    webformsStore.clearError();
+  };
+  const fetchWebform = async (id) => {
+    clearMessages();
+    formLoading.value = true;
     try {
-      const response = await get(`contact-center/webforms/${id}/details`);
-      if (response.status === "Success" && response.data) {
-        store.setWebform(response.data);
-        return response;
-      } else {
-        const errorMessage = formatErrorMessage(response.message);
-        store.setError(errorMessage);
-        throw new Error(errorMessage);
-      }
-    } catch (error) {
-      console.error("Fetch webform error:", error);
-      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to fetch webform";
-      store.setError(errorMessage);
-      throw new Error(errorMessage);
+      const result = await webformsStore.fetchWebform(id);
+      return result;
     } finally {
-      store.setLoading(false);
+      formLoading.value = false;
     }
-  }
-  async function submitInquiry(formData, recaptchaToken = "") {
-    store.setLoading(true);
-    store.setError(null);
+  };
+  const initFormSubmission = (formData) => {
+    clearMessages();
+    currentFormData.value = formData;
+    showSuccessModal.value = false;
+  };
+  const submitInquiry = async (formData) => {
+    formLoading.value = true;
+    clearMessages();
     try {
-      const data = { ...formData, recaptcha: recaptchaToken };
-      const response = await post("/contact-center/webforms/create", data);
+      const submissionData = {
+        ...formData,
+        recaptcha: recaptchaToken.value || formData.recaptcha
+      };
+      const response = await webformsStore.submitInquiry(submissionData);
       if (response.status === "Success") {
-        store.setWebFormReturn(response);
-        return response;
-      } else {
-        const errorMessage = formatErrorMessage(response.message);
-        store.setError(errorMessage);
-        throw new Error(errorMessage);
+        showSuccessModal.value = true;
+        currentFormData.value = null;
+        recaptchaToken.value = "";
       }
-    } catch (error) {
-      console.error("Submit inquiry error:", error);
-      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to submit inquiry";
-      store.setError(errorMessage);
-      throw new Error(errorMessage);
+      return response;
+    } catch (error2) {
+      console.error("Submit inquiry error:", error2);
+      return {
+        status: "Error",
+        message: error2.message || "Submission failed",
+        data: null
+      };
     } finally {
-      store.setLoading(false);
+      formLoading.value = false;
     }
-  }
+  };
+  const setRecaptchaToken = (token) => {
+    recaptchaToken.value = token;
+  };
+  const closeSuccessModal = () => {
+    showSuccessModal.value = false;
+    clearMessages();
+  };
+  const resetForm = () => {
+    currentFormData.value = null;
+    recaptchaToken.value = "";
+    clearMessages();
+    showSuccessModal.value = false;
+  };
+  const autoClearMessages = () => {
+    if (webFormReturn.value?.status !== void 0 || error.value) {
+      setTimeout(() => {
+        clearMessages();
+      }, 5e3);
+    }
+  };
+  const isFormValid = (formData) => {
+    if (!webform.value) return false;
+    const requiredFields = webform.value.fields.filter((field) => field.required);
+    return requiredFields.every((field) => {
+      const value = formData[field.name];
+      return value !== void 0 && value !== null && value !== "";
+    });
+  };
   return {
+    // State
+    showSuccessModal,
+    currentFormData,
+    recaptchaToken,
+    formLoading,
+    // Computed
+    webform,
+    webFormReturn,
+    loading,
+    error,
+    // Methods
+    clearMessages,
     fetchWebform,
+    initFormSubmission,
     submitInquiry,
-    webform: computed(() => store.webform),
-    webFormReturn: computed(() => store.webFormReturn),
-    loading: computed(() => store.loading),
-    error: computed(() => store.error)
+    setRecaptchaToken,
+    closeSuccessModal,
+    resetForm,
+    autoClearMessages,
+    isFormValid
   };
 }

package/dist/runtime/middleware/flowrix.d.ts

@@ -1,6 +1,7 @@
 export declare const flowrixApi: {
-    get: (endpoint: any, options?: {}, apiversion?: string) => Promise<unknown>;
-    post: (endpoint: any, options?: {}, apiversion?: string) => Promise<unknown>;
-    put: (endpoint: any, options?: {}, apiversion?: string) => Promise<unknown>;
-    delete: (endpoint: any, options?: {}, apiversion?: string) => Promise<unknown>;
+    get: (endpoint: any, config?: {}, options?: {}) => Promise<any>;
+    post: (endpoint: any, config?: {}, options?: {}) => Promise<any>;
+    put: (endpoint: any, config?: {}, options?: {}) => Promise<any>;
+    patch: (endpoint: any, config?: {}, options?: {}) => Promise<any>;
+    delete: (endpoint: any, config?: {}, options?: {}) => Promise<any>;
 };

package/dist/runtime/middleware/flowrix.js

@@ -1,42 +1,60 @@
 const isServer = typeof process !== "undefined" && process.server;
-function getEnv(key) {
-  if (typeof useRuntimeConfig === "function") {
-    const config = useRuntimeConfig();
-    console.log(config);
-    return config.public?.[key] || config[key];
+function getCookie(name) {
+  if (process.client) {
+    const value = `; ${document.cookie}`;
+    const parts = value.split(`; ${name}=`);
+    if (parts.length === 2) return parts.pop().split(";").shift();
+    return null;
+  } else {
+    return null;
   }
-  return process.env[key];
 }
-async function request(method, endpoint, options = {}, apiversion) {
-  console.log(endpoint);
-  const FLOWRIX_API_KEY = getEnv("FLOWRIX_API_KEY");
-  const FLOWRIX_API_SECRET = getEnv("FLOWRIX_API_SECRET");
-  const FLOWRIX_API_ORIGIN = getEnv("FLOWRIX_API_ORIGIN");
-  let FLOWRIX_API_BASE = getEnv("FLOWRIX_API_BASE");
-  if (apiversion == "v2") {
-    FLOWRIX_API_BASE = getEnv("FLOWRIX_API_BASE_V2");
-  }
+const parseCookies = (cookieString) => {
+  return Object.fromEntries(
+    cookieString.split(";").map((c) => {
+      const [key, ...v] = c.trim().split("=");
+      return [key, decodeURIComponent(v.join("="))];
+    })
+  );
+};
+async function request(method, config = {}, endpoint, options = {}) {
+  const FLOWRIX_API_KEY = config?.FLOWRIX_API_KEY || config.public?.FLOWRIX_API_KEY || "";
+  const FLOWRIX_API_ORIGIN = config?.FLOWRIX_API_ORIGIN || config.public?.FLOWRIX_API_ORIGIN || "";
+  let FLOWRIX_API_BASE = config?.FLOWRIX_API_BASE || config.public?.FLOWRIX_API_BASE || "";
+  const cookiesObj = parseCookies(config.cookies || "");
+  const authToken = cookiesObj["authToken"];
   const headers = {
-    "x-api-key": FLOWRIX_API_KEY,
-    "x-api-secret": FLOWRIX_API_SECRET,
+    "x-public-key": FLOWRIX_API_KEY,
+    "x-session-token": getCookie("x-session-token"),
+    "Access-Control-Expose-Headers": "x-session-token",
+    "authorization": `Bearer ${authToken}`,
     "Origin": FLOWRIX_API_ORIGIN,
     ...options.headers
   };
   try {
+    console.log("headers headers headers headers", headers);
     const response = await $fetch(`${FLOWRIX_API_BASE}${endpoint}`, {
       method,
       ...options,
-      headers
+      headers,
+      onResponse({ response: response2 }) {
+        const token = response2.headers.get("x-session-token");
+        if (token) {
+          if (process.client) {
+            document.cookie = `x-session-token=${token}; path=/; max-age=2592000; secure; SameSite=Lax`;
+          }
+        }
+      }
     });
     return response;
   } catch (error) {
-    console.error(`[FLOWRIX ERROR] ${method.toUpperCase()} ${FLOWRIX_API_BASE}${endpoint}`, error);
     throw error;
   }
 }
 export const flowrixApi = {
-  get: (endpoint, options = {}, apiversion = "v1") => request("get", endpoint, options, apiversion),
-  post: (endpoint, options = {}, apiversion = "v1") => request("post", endpoint, options, apiversion),
-  put: (endpoint, options = {}, apiversion = "v1") => request("put", endpoint, options, apiversion),
-  delete: (endpoint, options = {}, apiversion = "v1") => request("delete", endpoint, options, apiversion)
+  get: (endpoint, config = {}, options = {}) => request("get", config, endpoint, options),
+  post: (endpoint, config = {}, options = {}) => request("post", config, endpoint, options),
+  put: (endpoint, config = {}, options = {}) => request("put", config, endpoint, options),
+  patch: (endpoint, config = {}, options = {}) => request("patch", config, endpoint, options),
+  delete: (endpoint, config = {}, options = {}) => request("delete", config, endpoint, options)
 };

package/dist/runtime/middleware/flowrixs3.d.ts

@@ -0,0 +1,3 @@
+export declare const flowrixS3: {
+    get: (endpoint: any, config?: {}, options?: {}) => Promise<any>;
+};