flowrix 1.0.0

package/dist/runtime/composables/useTikTokDatalayer.js

@@ -0,0 +1,165 @@
+import { useCompanyProfile } from "../stores/useCompanyProfile.js";
+const getTtq = () => {
+  if (process.client && typeof window !== "undefined" && window.ttq) {
+    return window.ttq;
+  }
+  return null;
+};
+export function TikTok_page_view(to) {
+  const ttq = getTtq();
+  if (ttq) {
+    ttq.page();
+  }
+}
+export function TikTok_view_item(product, price = 0, rp = 0) {
+  const ttq = getTtq();
+  if (!ttq || !product) return;
+  let discount = rp > price ? Number((rp - price).toFixed(2)) : 0;
+  ttq.track("ViewContent", {
+    type: "product",
+    contents: [{
+      content_id: "SKU_" + product?.sku,
+      content_type: "product",
+      quantity: 1,
+      description: product?.category,
+      content_name: product?.name,
+      price: Number(rp) > 0 ? Number(rp) : Number(price),
+      currency: useCompanyProfile().profile?.currencyCode,
+      value: price
+    }]
+  });
+}
+export function TikTok_add_to_cart(lastitem = "") {
+  const ttq = getTtq();
+  if (!ttq || !lastitem) return;
+  let price = lastitem.pricefloat;
+  let discount = lastitem.rpfloat > lastitem.pricefloat ? Number((lastitem.rpfloat - lastitem.pricefloat).toFixed(2)) : 0;
+  const ecomarceCartItems = [{
+    content_id: "SKU_" + lastitem.sku,
+    content_type: "product",
+    content_name: lastitem.name,
+    price,
+    quantity: 1,
+    discount,
+    location_id: "online store"
+  }];
+  ttq.track("AddToCart", {
+    contents: ecomarceCartItems,
+    value: price,
+    currency: useCompanyProfile().profile?.currencyCode
+  });
+}
+export function TikTok_view_cart(cart = "") {
+  const ttq = getTtq();
+  if (!ttq || !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 {
+      content_id: "SKU_" + item.sku,
+      content_name: item.name,
+      content_type: "product",
+      quantity: item.qty,
+      price,
+      discount,
+      item_category: item.category
+    };
+  });
+  ttq.track("ViewCart", {
+    contents: ecomarceCartItems,
+    value: cart.totals.total,
+    currency: useCompanyProfile().profile?.currencyCode
+  });
+}
+export function TikTok_remove_from_cart(lastitem = "") {
+  const ttq = getTtq();
+  if (!ttq || !lastitem) return;
+  let price = lastitem.pricefloat;
+  let discount = lastitem.rpfloat > lastitem.pricefloat ? Number((lastitem.rpfloat - lastitem.pricefloat).toFixed(2)) : 0;
+  const ecomarceCartItems = [{
+    content_id: "SKU_" + lastitem.sku,
+    content_type: "product",
+    content_name: lastitem.name,
+    price,
+    quantity: lastitem.qty || 1,
+    discount,
+    location_id: "online store"
+  }];
+  ttq.track("RemoveFromCart", {
+    contents: ecomarceCartItems,
+    value: price,
+    currency: useCompanyProfile().profile?.currencyCode
+  });
+}
+export function TikTok_begin_checkout(cart = "") {
+  const ttq = getTtq();
+  if (!ttq || !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 {
+      content_id: "SKU_" + item.sku,
+      content_name: item.name,
+      content_type: "product",
+      quantity: item.qty,
+      price,
+      discount,
+      item_category: item.category
+    };
+  });
+  ttq.track("InitiateCheckout", {
+    contents: ecomarceCartItems,
+    value: cart.totals.total,
+    currency: useCompanyProfile().profile?.currencyCode
+  });
+}
+export function TikTok_add_payment_info(cart = "", payment_type = "") {
+  const ttq = getTtq();
+  if (!ttq || !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 {
+      content_id: "SKU_" + item.sku,
+      content_name: item.name,
+      content_type: "product",
+      quantity: item.qty,
+      price,
+      discount,
+      item_category: item.category
+    };
+  });
+  ttq.track("AddPaymentInfo", {
+    contents: ecomarceCartItems,
+    payment_type,
+    value: cart.totals.total,
+    currency: useCompanyProfile().profile?.currencyCode
+  });
+}
+export function TikTok_purchase(orderData = "", cart = "") {
+  const ttq = getTtq();
+  if (!ttq || !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 {
+      content_id: "SKU_" + item.sku,
+      content_name: item.name,
+      content_type: "product",
+      quantity: item.qty,
+      price,
+      discount,
+      item_category: item.category
+    };
+  });
+  ttq.track("Purchase", {
+    contents: purchaseitems,
+    value: orderData.grandtotalFloat,
+    currency: useCompanyProfile().profile?.currencyCode,
+    transaction_id: orderData.order_no,
+    affiliation: "online Store",
+    tax: orderData.tax,
+    shipping: orderData.shipping,
+    coupon: orderData.vouchercode
+  });
+}

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

@@ -0,0 +1,16 @@
+import { type WebForm, type WebFormData } from '../stores/webforms.js';
+export interface ApiResponse<T> {
+    status: string;
+    message: string | Record<string, string[]> | null;
+    data: T | null;
+}
+export declare function useWebforms(): {
+    fetchWebform: (id: number) => Promise<ApiResponse<WebForm>>;
+    submitInquiry: (formData: WebFormData, recaptchaToken?: string) => Promise<ApiResponse<any>>;
+    webform: import("vue").ComputedRef<{
+        id: number;
+    } | null>;
+    webFormReturn: import("vue").ComputedRef<any>;
+    loading: import("vue").ComputedRef<boolean>;
+    error: import("vue").ComputedRef<string | null>;
+};

package/dist/runtime/composables/useWebforms.js

@@ -0,0 +1,75 @@
+import { 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);
+    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);
+    } finally {
+      store.setLoading(false);
+    }
+  }
+  async function submitInquiry(formData, recaptchaToken = "") {
+    store.setLoading(true);
+    store.setError(null);
+    try {
+      const data = { ...formData, recaptcha: recaptchaToken };
+      const response = await post("/contact-center/webforms/create", data);
+      if (response.status === "Success") {
+        store.setWebFormReturn(response);
+        return response;
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        store.setError(errorMessage);
+        throw new Error(errorMessage);
+      }
+    } 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);
+    } finally {
+      store.setLoading(false);
+    }
+  }
+  return {
+    fetchWebform,
+    submitInquiry,
+    webform: computed(() => store.webform),
+    webFormReturn: computed(() => store.webFormReturn),
+    loading: computed(() => store.loading),
+    error: computed(() => store.error)
+  };
+}

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

@@ -0,0 +1,38 @@
+import { type Wishlist, type WishlistProduct } from '../stores/wishlists.js';
+export interface ApiResponse<T> {
+    status: string;
+    message: string | Record<string, string[]> | null;
+    data: T | null;
+}
+export interface CreateWishlistData {
+    title: string;
+    default: boolean;
+}
+export interface UpdateWishlistData {
+    title: string;
+    default: boolean;
+}
+export interface AddToWishlistData {
+}
+export declare function useWishlists(): {
+    fetchWishlists: () => Promise<ApiResponse<Wishlist[]>>;
+    fetchWishlistProducts: (listId: number) => Promise<ApiResponse<{
+        id: number;
+        title: string;
+        default: boolean;
+        created_at: string;
+        products: WishlistProduct[];
+    }>>;
+    createWishlist: (data: CreateWishlistData) => Promise<ApiResponse<Wishlist>>;
+    addToWishlist: (listId: number, productSlug: string, data?: AddToWishlistData) => Promise<ApiResponse<WishlistProduct>>;
+    removeFromWishlist: (listId: number, productSlug: string) => Promise<ApiResponse<void>>;
+    updateWishlist: (id: number, data: UpdateWishlistData) => Promise<ApiResponse<Wishlist>>;
+    deleteWishlist: (id: number) => Promise<ApiResponse<void>>;
+    wishlists: import("vue").ComputedRef<{
+        id: number;
+        name?: string | undefined;
+    }[]>;
+    wishlistProducts: import("vue").ComputedRef<import("../stores/index.js").WishlistProducts>;
+    loading: import("vue").ComputedRef<boolean>;
+    error: import("vue").ComputedRef<string | null>;
+};

package/dist/runtime/composables/useWishlists.js

@@ -0,0 +1,191 @@
+import { computed } from "vue";
+import { useWishlistsStore } from "../stores/wishlists.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 useWishlists() {
+  const store = useWishlistsStore();
+  const { get, post } = useApi();
+  async function fetchWishlists() {
+    store.setLoading(true);
+    store.setError(null);
+    try {
+      const response = await get("/customer/wishlist");
+      if (response.status === "Success" && response.data) {
+        store.setWishlists(response.data);
+        return response;
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        store.setError(errorMessage);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      console.error("Fetch wishlists error:", error);
+      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to fetch wishlists";
+      store.setError(errorMessage);
+      throw new Error(errorMessage);
+    } finally {
+      store.setLoading(false);
+    }
+  }
+  async function fetchWishlistProducts(listId) {
+    store.setLoading(true);
+    store.setError(null);
+    try {
+      const response = await get(`/customer/wishlist/${listId}/products`);
+      if (response.status === "Success" && response.data) {
+        const products = response.data.products || [];
+        store.setWishlistProducts(listId, products);
+        return response;
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        store.setError(errorMessage);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      console.error("Fetch wishlist products error:", error);
+      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to fetch wishlist products";
+      store.setError(errorMessage);
+      throw new Error(errorMessage);
+    } finally {
+      store.setLoading(false);
+    }
+  }
+  async function createWishlist(data) {
+    store.setLoading(true);
+    store.setError(null);
+    try {
+      const response = await post("/customer/wishlist/add", data);
+      if (response.status === "Success" && response.data) {
+        store.addWishlist(response.data);
+        return response;
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        store.setError(errorMessage);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      console.error("Create wishlist error:", error);
+      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to create wishlist";
+      store.setError(errorMessage);
+      throw new Error(errorMessage);
+    } finally {
+      store.setLoading(false);
+    }
+  }
+  async function addToWishlist(listId, productSlug, data = {}) {
+    store.setLoading(true);
+    store.setError(null);
+    try {
+      const response = await post(`/customer/wishlist/${listId}/${productSlug}/add`, data);
+      if (response.status === "Success" && response.data) {
+        store.addWishlistProduct(listId, response.data);
+        return response;
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        store.setError(errorMessage);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      console.error("Add to wishlist error:", error);
+      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to add to wishlist";
+      store.setError(errorMessage);
+      throw new Error(errorMessage);
+    } finally {
+      store.setLoading(false);
+    }
+  }
+  async function removeFromWishlist(listId, productSlug) {
+    store.setLoading(true);
+    store.setError(null);
+    try {
+      const response = await post(`/customer/wishlist/${listId}/item/delete`, { ids: { productSlug } });
+      if (response.status === "Success") {
+        store.removeWishlistProduct(listId, productSlug);
+        return response;
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        store.setError(errorMessage);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      console.error("Remove from wishlist error:", error);
+      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to remove from wishlist";
+      store.setError(errorMessage);
+      throw new Error(errorMessage);
+    } finally {
+      store.setLoading(false);
+    }
+  }
+  async function updateWishlist(id, data) {
+    store.setLoading(true);
+    store.setError(null);
+    try {
+      const response = await post(`/customer/wishlist/${id}/update`, data);
+      if (response.status === "Success" && response.data) {
+        store.updateWishlist(response.data);
+        return response;
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        store.setError(errorMessage);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      console.error("Update wishlist error:", error);
+      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to update wishlist";
+      store.setError(errorMessage);
+      throw new Error(errorMessage);
+    } finally {
+      store.setLoading(false);
+    }
+  }
+  async function deleteWishlist(id) {
+    store.setLoading(true);
+    store.setError(null);
+    try {
+      const response = await post(`/customer/wishlist/${id}/delete`, {});
+      if (response.status === "Success") {
+        store.removeWishlist(id);
+        store.clearWishlistProducts(id);
+        return response;
+      } else {
+        const errorMessage = formatErrorMessage(response.message);
+        store.setError(errorMessage);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      console.error("Delete wishlist error:", error);
+      const errorMessage = error.data ? formatErrorMessage(error.data.message) : error.message || "Failed to delete wishlist";
+      store.setError(errorMessage);
+      throw new Error(errorMessage);
+    } finally {
+      store.setLoading(false);
+    }
+  }
+  return {
+    fetchWishlists,
+    fetchWishlistProducts,
+    createWishlist,
+    addToWishlist,
+    removeFromWishlist,
+    updateWishlist,
+    deleteWishlist,
+    wishlists: computed(() => store.wishlists),
+    wishlistProducts: computed(() => store.wishlistProducts),
+    loading: computed(() => store.loading),
+    error: computed(() => store.error)
+  };
+}

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

@@ -0,0 +1,6 @@
+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>;
+};

package/dist/runtime/middleware/flowrix.js

@@ -0,0 +1,40 @@
+const isServer = typeof process !== "undefined" && process.server;
+function getEnv(key) {
+  if (typeof useRuntimeConfig === "function") {
+    const config = useRuntimeConfig();
+    return config.public?.[key] || config[key];
+  }
+  return process.env[key];
+}
+async function request(method, endpoint, options = {}, apiversion) {
+  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 headers = {
+    "x-api-key": FLOWRIX_API_KEY,
+    "x-api-secret": FLOWRIX_API_SECRET,
+    "Origin": FLOWRIX_API_ORIGIN,
+    ...options.headers
+  };
+  try {
+    const response = await $fetch(`${FLOWRIX_API_BASE}${endpoint}`, {
+      method,
+      ...options,
+      headers
+    });
+    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)
+};

package/dist/runtime/plugin.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugin.js

@@ -0,0 +1,4 @@
+import { defineNuxtPlugin } from "#app";
+export default defineNuxtPlugin((_nuxtApp) => {
+  console.log("Plugin injected by flowrix!");
+});

package/dist/runtime/plugins/persistedstate.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/plugins/persistedstate.client.js

@@ -0,0 +1,9 @@
+import piniaPluginPersistedstate from "pinia-plugin-persistedstate";
+export default defineNuxtPlugin((nuxtApp) => {
+  if (nuxtApp?.$pinia) {
+    nuxtApp.$pinia.use(piniaPluginPersistedstate);
+  } else {
+    const { $pinia } = useNuxtApp();
+    if ($pinia) $pinia.use(piniaPluginPersistedstate);
+  }
+});

package/dist/runtime/server/api/albums.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/server/api/albums.js

@@ -0,0 +1,18 @@
+import { defineEventHandler, setResponseStatus } from "h3";
+import { $fetch } from "ofetch";
+export default defineEventHandler(async (event) => {
+  try {
+    const albums = await $fetch(`${process.env.FLOWRIX_API_BASE}albums`, {
+      method: "GET",
+      headers: {
+        "x-api-key": process.env.FLOWRIX_API_KEY,
+        "x-api-secret": process.env.FLOWRIX_API_SECRET,
+        "Origin": process.env.FLOWRIX_API_ORIGIN
+      }
+    });
+    return albums;
+  } catch (error) {
+    setResponseStatus(event, 500);
+    return { success: false, error: error.message };
+  }
+});

package/dist/runtime/server/api/auth/forgot.d.ts

@@ -0,0 +1,5 @@
+interface APIResponse {
+    token: string;
+}
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<APIResponse>>;
+export default _default;

package/dist/runtime/server/api/auth/forgot.js

@@ -0,0 +1,44 @@
+import { defineEventHandler, readBody, createError } from "h3";
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event);
+  const { email } = body;
+  try {
+    const response = await fetch(`${process.env.FLOWRIX_API_BASE}verify-email/`, {
+      method: "POST",
+      headers: {
+        "x-api-key": process.env.FLOWRIX_API_KEY,
+        "x-api-secret": process.env.FLOWRIX_API_SECRET,
+        "Origin": process.env.FLOWRIX_API_ORIGIN,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ email })
+    });
+    if (!response.ok) {
+      let errorMessage = ``;
+      try {
+        const errorData = await response.json();
+        console.error("Error response data:", errorData.message);
+        if (errorData.message) {
+          errorMessage += errorData.message?.email || errorData.message;
+        }
+      } catch (parseError) {
+        errorMessage += "Failed to parse error details.";
+      }
+      throw createError({
+        status: 400,
+        statusMessage: "Bad Request",
+        message: "Invalid user input",
+        data: { field: "email" }
+      });
+    }
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    throw createError({
+      status: 400,
+      statusMessage: "Bad Request",
+      message: "Invalid user input",
+      data: { field: "email" }
+    });
+  }
+});

package/dist/runtime/server/api/auth/login.d.ts

@@ -0,0 +1,11 @@
+interface AuthUser {
+    id: string | number;
+    email: string;
+    firstName?: string;
+    lastName?: string;
+}
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    user: AuthUser;
+    token: string;
+}>>;
+export default _default;