flowrix 1.0.0

package/dist/runtime/composables/Blog/useBlogSingle.d.ts

@@ -0,0 +1,30 @@
+interface PostData {
+    meta_title?: string;
+    meta_description?: string;
+    content?: {
+        css?: string;
+    };
+}
+interface MagazineCard {
+    CardImg: string;
+    CardTitle: string;
+}
+interface BlogSingleProps {
+    postData?: PostData;
+}
+export declare const useBlogSingle: (props: BlogSingleProps) => {
+    magazineCards: import("vue").Ref<{
+        CardImg: string;
+        CardTitle: string;
+    }[], MagazineCard[] | {
+        CardImg: string;
+        CardTitle: string;
+    }[]>;
+    loading: import("vue").Ref<boolean, boolean>;
+    total: import("vue").Ref<number, number>;
+    progressPercentage: import("vue").ComputedRef<number>;
+    canLoadMore: import("vue").ComputedRef<boolean>;
+    fullPath: import("vue").ComputedRef<string>;
+    loadMore: () => Promise<void>;
+};
+export {};

package/dist/runtime/composables/Blog/useBlogSingle.js

@@ -0,0 +1,87 @@
+import { ref, computed } from "vue";
+import { useRoute, useRequestHeaders, useHead } from "#imports";
+import magazineImg1 from "@/assets/images/single-blog/Mask Group 79.png";
+import magazineImg2 from "@/assets/images/single-blog/Mask Group 80.png";
+export const useBlogSingle = (props) => {
+  const route = useRoute();
+  const magazineCards = ref([
+    {
+      CardImg: magazineImg1,
+      CardTitle: "What is Matter Technology and Why Does it Matter?"
+    },
+    {
+      CardImg: magazineImg2,
+      CardTitle: "Easily convert your existing roller blinds into smart shades"
+    }
+  ]);
+  const loading = ref(false);
+  const limit = 4;
+  const total = ref(magazineCards.value.length);
+  const currentIndex = ref(magazineCards.value.length);
+  const loadMore = async () => {
+    if (loading.value || currentIndex.value >= total.value) return;
+    loading.value = true;
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    const nextProducts = magazineCards.value.slice(currentIndex.value, currentIndex.value + limit);
+    magazineCards.value.push(...nextProducts);
+    currentIndex.value += nextProducts.length;
+    loading.value = false;
+  };
+  const fullPath = computed(() => {
+    if (process.server) {
+      const headers = useRequestHeaders();
+      const protocol = headers["x-forwarded-proto"] || "http";
+      const host = headers.host || "localhost";
+      return `${protocol}://${host}${route.fullPath}`;
+    } else {
+      return `${window.location.origin}${route.fullPath}`;
+    }
+  });
+  const setupSEO = () => {
+    useHead(() => {
+      const css = props.postData?.content?.css || "";
+      return {
+        style: css ? [{
+          children: css,
+          type: "text/css"
+        }] : []
+      };
+    });
+    useHead({
+      title: props.postData?.meta_title || "Blog Post",
+      meta: [
+        {
+          name: "description",
+          content: props.postData?.meta_description || ""
+        },
+        {
+          name: "og:title",
+          content: props.postData?.meta_title || ""
+        },
+        {
+          name: "og:description",
+          content: props.postData?.meta_description || ""
+        },
+        {
+          name: "og:url",
+          content: fullPath.value
+        }
+      ]
+    });
+  };
+  const progressPercentage = computed(() => magazineCards.value.length / total.value * 100);
+  const canLoadMore = computed(() => !loading.value && magazineCards.value.length < total.value);
+  setupSEO();
+  return {
+    // State
+    magazineCards,
+    loading,
+    total,
+    // Computed
+    progressPercentage,
+    canLoadMore,
+    fullPath,
+    // Methods
+    loadMore
+  };
+};

package/dist/runtime/composables/Blog/useMagazineCard.d.ts

@@ -0,0 +1,13 @@
+interface MagazineCard {
+    CardImg: string;
+    CardTitle: string;
+    url?: string;
+}
+interface MagazineCardProps {
+    magazineCard: MagazineCard;
+}
+export declare const useMagazineCard: (props: MagazineCardProps) => {
+    card: import("vue").ComputedRef<MagazineCard>;
+    navigateToArticle: () => void;
+};
+export {};

package/dist/runtime/composables/Blog/useMagazineCard.js

@@ -0,0 +1,14 @@
+import { computed } from "vue";
+import { navigateTo } from "#imports";
+export const useMagazineCard = (props) => {
+  const card = computed(() => props.magazineCard);
+  const navigateToArticle = () => {
+    if (card.value.url) {
+      navigateTo(card.value.url);
+    }
+  };
+  return {
+    card,
+    navigateToArticle
+  };
+};

package/dist/runtime/composables/Blog/useSingleBlogMain.d.ts

@@ -0,0 +1,20 @@
+interface BlogContent {
+    html: string;
+}
+interface BlogPostData {
+    name: string;
+    author: string;
+    publish_date: string;
+    category: string;
+    image_url: string;
+    content: BlogContent;
+}
+interface SingleBlogMainProps {
+    postData: BlogPostData;
+}
+export declare const useSingleBlogMain: (props: SingleBlogMainProps) => {
+    post: import("vue").ComputedRef<BlogPostData>;
+    formattedDate: import("vue").ComputedRef<string>;
+    navigateToCategory: () => void;
+};
+export {};

package/dist/runtime/composables/Blog/useSingleBlogMain.js

@@ -0,0 +1,28 @@
+import { computed } from "vue";
+import { navigateTo } from "#imports";
+export const useSingleBlogMain = (props) => {
+  const post = computed(() => props.postData);
+  const formattedDate = computed(() => {
+    if (!post.value.publish_date) return "";
+    try {
+      const date = new Date(post.value.publish_date);
+      return date.toLocaleDateString("en-US", {
+        year: "numeric",
+        month: "long",
+        day: "numeric"
+      });
+    } catch (error) {
+      return post.value.publish_date;
+    }
+  });
+  const navigateToCategory = () => {
+    if (post.value.category) {
+      navigateTo(`/blog/category/${post.value.category.toLowerCase()}`);
+    }
+  };
+  return {
+    post,
+    formattedDate,
+    navigateToCategory
+  };
+};

package/dist/runtime/composables/Brand/brand.d.ts

@@ -0,0 +1,7 @@
+export declare function useBrand(template: {
+    template: string;
+}): {
+    Brandtemplate: any;
+    brandData: any;
+    pending: any;
+};

package/dist/runtime/composables/Brand/brand.js

@@ -0,0 +1,45 @@
+import { defineAsyncComponent, watch } from "vue";
+export function useBrand(template) {
+  const route = useRoute();
+  const components = import.meta.glob(
+    "~/components/Brand/Template*/**/index.vue"
+  );
+  const path = `/components/Brand/Template-${template}/index.vue`;
+  const fallbackPath = `/components/Brand/Template-default/index.vue`;
+  const Brandtemplate = defineAsyncComponent({
+    loader: async () => {
+      if (template) {
+        if (components[path]) {
+          return await components[path]();
+        } else {
+          return await components[fallbackPath]();
+        }
+      }
+    }
+  });
+  const slug = route.params.slug;
+  const query = route.query;
+  const { data: brandData, error, pending, refresh } = useFetch(`/api/brand/${slug}`, {
+    query
+  });
+  watch(brandData, (newData) => {
+  }, { immediate: true });
+  watch(
+    () => [route.path, route.query],
+    async () => {
+      pending.value = true;
+      const response = await useFetch(`/api/brand/${slug}`, {
+        method: "GET",
+        query: route.query
+      });
+      brandData.value = response.data.value;
+      pending.value = false;
+    },
+    { deep: true }
+  );
+  return {
+    Brandtemplate,
+    brandData,
+    pending
+  };
+}

package/dist/runtime/composables/Cart/useCartDetail.d.ts

@@ -0,0 +1,49 @@
+interface Product {
+    name: string;
+    height?: number;
+    width?: number;
+    type: string;
+    image: string;
+    options: {
+        promotionlabel: Array<{
+            cartPromotionTag: string;
+            cartPromotionTagBackgroundColor: string;
+            cartPromotionTagColor: string;
+            cartDescription?: string;
+        }>;
+        summary: Array<{
+            name: string;
+            value: string;
+        }>;
+    };
+    pricefloat: number;
+    qty: number;
+    rpfloat: number;
+    rowId: string;
+    slug: string;
+    bundle?: Array<{
+        name: string;
+        qty: number;
+        price: string;
+        image?: string;
+        rrp?: string;
+    }>;
+    service?: {
+        per_order_pricing: number;
+    };
+}
+interface CartDetailProps {
+    items: Record<string, Product>;
+}
+export declare const useCartDetail: (props: CartDetailProps) => {
+    productAccordionStates: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
+    cartItems: import("vue").ComputedRef<Record<string, Product>>;
+    companyProfile: any;
+    checkoutData: import("vue").ComputedRef<any>;
+    removeFromCartMiddleware: (productId: string, product: Product) => Promise<void>;
+    updateQuantityMiddleware: (product: Product, qty: number) => Promise<void>;
+    toggleAccordion: (rowId: string) => void;
+    dvidedsummary: (sammarydata: any[]) => any[][];
+    swatchimagesSrcset: (swatchImage: string) => string;
+};
+export {};

package/dist/runtime/composables/Cart/useCartDetail.js

@@ -0,0 +1,48 @@
+import { onMounted, ref, computed } from "vue";
+export const useCartDetail = (props) => {
+  const cartStore = useCartStore();
+  const { profile: companyProfile } = useCompanyProfile();
+  const checkoutData = computed(() => useCheckoutStore().config);
+  const productAccordionStates = ref({});
+  onMounted(() => {
+    window.scrollTo({
+      top: 0,
+      behavior: "smooth"
+    });
+  });
+  const removeFromCartMiddleware = async (productId, product) => {
+    await cartStore.removeFromCart(productId, product);
+  };
+  const updateQuantityMiddleware = async (product, qty) => {
+    await cartStore.updateQuantity(product, qty);
+  };
+  const toggleAccordion = (rowId) => {
+    productAccordionStates.value[rowId] = !productAccordionStates.value[rowId];
+  };
+  const dvidedsummary = (sammarydata) => {
+    const sumary = [];
+    const firstMidpoint = Math.ceil(sammarydata.length / 2);
+    sumary[0] = sammarydata.slice(0, firstMidpoint);
+    sumary[1] = sammarydata.slice(firstMidpoint);
+    return sumary;
+  };
+  const swatchimagesSrcset = (swatchImage) => {
+    const swatchImage320 = swatchImage?.replace(/.webp/gi, "320.webp");
+    return swatchImage320;
+  };
+  const cartItems = computed(() => props.items);
+  return {
+    // State
+    productAccordionStates,
+    // Computed
+    cartItems,
+    companyProfile,
+    checkoutData,
+    // Methods
+    removeFromCartMiddleware,
+    updateQuantityMiddleware,
+    toggleAccordion,
+    dvidedsummary,
+    swatchimagesSrcset
+  };
+};

package/dist/runtime/composables/Category/useCategoryContent.d.ts

@@ -0,0 +1,9 @@
+interface CategoryContentProps {
+    description: string;
+}
+export declare const useCategoryContent: (props: CategoryContentProps) => {
+    description: import("vue").ComputedRef<string>;
+    processedDescription: import("vue").ComputedRef<string>;
+    sanitizeContent: (content: string) => string;
+};
+export {};

package/dist/runtime/composables/Category/useCategoryContent.js

@@ -0,0 +1,15 @@
+import { computed } from "vue";
+export const useCategoryContent = (props) => {
+  const description = computed(() => props.description);
+  const sanitizeContent = (content) => {
+    return content;
+  };
+  const processedDescription = computed(() => {
+    return sanitizeContent(description.value);
+  });
+  return {
+    description,
+    processedDescription,
+    sanitizeContent
+  };
+};

package/dist/runtime/composables/Category/useCategoryGrid.d.ts

@@ -0,0 +1,40 @@
+interface Product {
+    id: string | number;
+    name: string;
+    image: string;
+    price: number;
+}
+interface ChildCategory {
+    slug: string;
+    name: string;
+    image: string;
+    short_description: string;
+}
+interface CategoryGridProps {
+    template: number;
+    childcategories: ChildCategory[];
+    products: Product[];
+}
+export declare const useCategoryGrid: (props: CategoryGridProps) => {
+    selectedProduct: import("vue").Ref<{
+        id: string | number;
+        name: string;
+        image: string;
+        price: number;
+    } | null, Product | {
+        id: string | number;
+        name: string;
+        image: string;
+        price: number;
+    } | null>;
+    showQuickView: import("vue").Ref<boolean, boolean>;
+    template: import("vue").ComputedRef<number>;
+    childcategories: import("vue").ComputedRef<ChildCategory[]>;
+    products: import("vue").ComputedRef<Product[]>;
+    shouldShowProducts: import("vue").ComputedRef<boolean>;
+    shouldShowCategories: import("vue").ComputedRef<boolean>;
+    openQuickView: (data: Product) => void;
+    closeQuickView: () => void;
+    formatShortDescription: (html: string) => string;
+};
+export {};

package/dist/runtime/composables/Category/useCategoryGrid.js

@@ -0,0 +1,38 @@
+import { ref, computed } from "vue";
+export const useCategoryGrid = (props) => {
+  const selectedProduct = ref(null);
+  const showQuickView = ref(false);
+  const openQuickView = (data) => {
+    selectedProduct.value = data;
+    showQuickView.value = true;
+  };
+  const closeQuickView = () => {
+    showQuickView.value = false;
+    selectedProduct.value = null;
+  };
+  const formatShortDescription = (html) => {
+    const text = html.replace(/<[^>]*>/g, "");
+    const words = text.split(/\s+/);
+    return words.slice(0, 30).join(" ") + (words.length > 30 ? "..." : "");
+  };
+  const template = computed(() => props.template);
+  const childcategories = computed(() => props.childcategories);
+  const products = computed(() => props.products);
+  const shouldShowProducts = computed(() => template.value !== 3);
+  const shouldShowCategories = computed(() => template.value === 3 && childcategories.value.length > 0);
+  return {
+    // State
+    selectedProduct,
+    showQuickView,
+    // Computed
+    template,
+    childcategories,
+    products,
+    shouldShowProducts,
+    shouldShowCategories,
+    // Methods
+    openQuickView,
+    closeQuickView,
+    formatShortDescription
+  };
+};

package/dist/runtime/composables/Category/useCategoryIndex.d.ts

@@ -0,0 +1,33 @@
+import { type Ref, type ComputedRef } from 'vue';
+interface CategoryData {
+    status: string;
+    message: number;
+    data: {
+        template: any;
+        type: string;
+        record: {
+            category: object;
+            products: object;
+            brands: object[];
+            filter_values: object[];
+            filters: object[];
+            categories: object[];
+            prices: object;
+            breadcrumb: string;
+        };
+    };
+}
+interface CategoryIndexProps {
+    data: CategoryData;
+}
+interface UseCategoryIndexReturn {
+    catData: Ref<any>;
+    error: Ref<any>;
+    pending: Ref<boolean>;
+    transformedApiData: ComputedRef<CategoryData | null>;
+    renderData: ComputedRef<CategoryData>;
+    refresh: () => Promise<void>;
+    getSelectedTemplate: (templateComponents: Record<string, any>) => ComputedRef<any>;
+}
+export declare const useCategoryIndex: (props: CategoryIndexProps) => UseCategoryIndexReturn;
+export {};

package/dist/runtime/composables/Category/useCategoryIndex.js

@@ -0,0 +1,65 @@
+import { useRoute, useFetch } from "#imports";
+import { watch, computed } from "vue";
+export const useCategoryIndex = (props) => {
+  const route = useRoute();
+  const slug = route.params.slug;
+  const { data: catData, error, pending, refresh } = useFetch(`/api/category/${slug}`, {
+    method: "GET",
+    query: route.query
+  });
+  watch(catData, (newData) => {
+  }, { immediate: true });
+  watch(
+    () => [route.path, route.query],
+    async () => {
+      pending.value = true;
+      const response = await useFetch(`/api/category/${slug}`, {
+        method: "GET",
+        query: route.query
+      });
+      catData.value = response.data.value;
+      pending.value = false;
+    },
+    { deep: true }
+  );
+  const transformedApiData = computed(() => {
+    if (catData.value && catData.value.status === "Success") {
+      return {
+        status: catData.value.status,
+        message: catData.value.message,
+        data: {
+          template: catData.value.data?.category?.template || "default",
+          type: catData.value.data?.type || "category",
+          record: {
+            category: catData.value.data?.category || {},
+            products: catData.value.data?.products || {},
+            brands: catData.value.data?.brands || [],
+            filter_values: catData.value.data?.filter_values || [],
+            filters: catData.value.data?.filters || [],
+            categories: catData.value.data?.categories || [],
+            prices: catData.value.data?.prices || {},
+            breadcrumb: catData.value.data?.breadcrumb || ""
+          }
+        }
+      };
+    }
+    return null;
+  });
+  const renderData = computed(() => transformedApiData.value || props.data);
+  const getSelectedTemplate = (templateComponents) => {
+    return computed(() => {
+      return templateComponents[renderData.value?.data?.template] || templateComponents.default;
+    });
+  };
+  return {
+    // State
+    catData,
+    error,
+    pending,
+    transformedApiData,
+    renderData,
+    // Methods
+    refresh,
+    getSelectedTemplate
+  };
+};

package/dist/runtime/composables/Category/useCategoryTemplate2.d.ts

@@ -0,0 +1,50 @@
+interface CategoryItem {
+    name: string;
+    slug: string;
+    image: string;
+    short_description: string;
+    sortorder?: number;
+    type?: string;
+    category?: string;
+}
+interface CategoryData {
+    category: {
+        name: string;
+    };
+    categories: CategoryItem[];
+    products: {
+        data: CategoryItem[];
+    };
+    prices?: {
+        minPrice: number;
+    };
+}
+interface CategoryTemplate2Props {
+    data: CategoryData;
+}
+export declare const useCategoryTemplate2: (props: CategoryTemplate2Props) => {
+    companyProfile: any;
+    data: import("vue").ComputedRef<CategoryData>;
+    categoryData: import("vue").ComputedRef<{
+        type: string;
+        name: string;
+        slug: string;
+        image: string;
+        short_description: string;
+        sortorder?: number;
+        category?: string;
+    }[]>;
+    hasProducts: import("vue").ComputedRef<boolean>;
+    categoryName: import("vue").ComputedRef<string>;
+    getCategoryData: (CatData: CategoryData) => {
+        type: string;
+        name: string;
+        slug: string;
+        image: string;
+        short_description: string;
+        sortorder?: number;
+        category?: string;
+    }[];
+    formatShortDescription: (html: string | null | undefined) => string;
+};
+export {};

package/dist/runtime/composables/Category/useCategoryTemplate2.js

@@ -0,0 +1,43 @@
+import { computed } from "vue";
+import { useCompanyProfile } from "../Extras/useCompanyProfile";
+export const useCategoryTemplate2 = (props) => {
+  const { profile: companyProfile } = useCompanyProfile();
+  const getCategoryData = (CatData) => {
+    const childCategories = CatData.categories.map((item) => ({
+      ...item,
+      type: "category"
+    }));
+    const products = CatData.products.data.filter((item) => item.category === CatData.category.name).map((item) => ({
+      ...item,
+      type: "product"
+    }));
+    const newData = [...childCategories, ...products].sort(
+      (a, b) => (a.sortorder || 0) - (b.sortorder || 0)
+    );
+    return newData;
+  };
+  const formatShortDescription = (html) => {
+    if (html === null || html === void 0) {
+      return "";
+    }
+    const text = html.replace(/<[^>]*>/g, "");
+    const words = text.split(/\s+/);
+    return words.slice(0, 30).join(" ") + (words.length > 30 ? "..." : "");
+  };
+  const data = computed(() => props.data);
+  const categoryData = computed(() => getCategoryData(data.value));
+  const hasProducts = computed(() => data.value.products.data.length > 0);
+  const categoryName = computed(() => data.value.category?.name || "");
+  return {
+    // State
+    companyProfile,
+    // Computed
+    data,
+    categoryData,
+    hasProducts,
+    categoryName,
+    // Methods
+    getCategoryData,
+    formatShortDescription
+  };
+};