flowrix 1.0.1-beta.13 → 1.0.1-beta.131

package/dist/module.d.mts

@@ -1,8 +1,3 @@
-import * as _nuxt_schema from '@nuxt/schema';
-
-interface ModuleOptions {
-}
-declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+declare const _default: any;
 
 export { _default as default };
-export type { ModuleOptions };

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "flowrix",
   "configKey": "flowrix",
-  "version": "1.0.1-beta.13",
+  "version": "1.0.1-beta.131",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -1,32 +1,40 @@
-import { defineNuxtModule, createResolver, installModule, addServerHandler, addImportsDir, addPlugin, addImports } from '@nuxt/kit';
+import { defineNuxtModule, createResolver, installModule, addPlugin, addServerHandler, addImportsDir, addImports } from '@nuxt/kit';
 
-const module = defineNuxtModule({
+const module$1 = defineNuxtModule({
   meta: {
     name: "flowrix",
     configKey: "flowrix"
   },
   defaults: {},
   async setup(_options, nuxt) {
-    nuxt.options.runtimeConfig = {
-      ...nuxt.options.runtimeConfig,
-      // Server-only key
-      FLOWRIX_API_KEY: nuxt.options.runtimeConfig.FLOWRIX_API_KEY || process.env.FLOWRIX_API_KEY || "",
-      FLOWRIX_API_SECRET: nuxt.options.runtimeConfig.FLOWRIX_API_SECRET || process.env.FLOWRIX_API_SECRET || "",
-      FLOWRIX_API_ORIGIN: nuxt.options.runtimeConfig.FLOWRIX_API_ORIGIN || process.env.FLOWRIX_API_ORIGIN || "",
-      FLOWRIX_API_BASE: nuxt.options.runtimeConfig.FLOWRIX_API_BASE || process.env.FLOWRIX_API_BASE || "",
-      FLOWRIX_API_BASE_V2: nuxt.options.runtimeConfig.FLOWRIX_API_BASE_V2 || process.env.FLOWRIX_API_BASE_V2 || "",
-      public: {
-        ...nuxt.options.runtimeConfig.public,
-        // Client-exposed key
-        FLOWRIX_API_KEY: nuxt.options.runtimeConfig.public?.FLOWRIX_API_KEY || process.env.FLOWRIX_API_KEY || "",
-        FLOWRIX_API_SECRET: nuxt.options.runtimeConfig.public?.FLOWRIX_API_SECRET || process.env.FLOWRIX_API_SECRET || "",
-        FLOWRIX_API_ORIGIN: nuxt.options.runtimeConfig.public?.FLOWRIX_API_ORIGIN || process.env.FLOWRIX_API_ORIGIN || "",
-        FLOWRIX_API_BASE: nuxt.options.runtimeConfig.public?.FLOWRIX_API_BASE || process.env.FLOWRIX_API_BASE || "",
-        FLOWRIX_API_BASE_V2: nuxt.options.runtimeConfig.public?.FLOWRIX_API_BASE_V2 || process.env.FLOWRIX_API_BASE_V2 || ""
-      }
-    };
+    const env = process.env;
+    const runtimeConfig = nuxt.options.runtimeConfig;
+    runtimeConfig.FLOWRIX_API_KEY = env.KEY || "";
+    runtimeConfig.FLOWRIX_API_SECRET = env.SECRET || "";
+    runtimeConfig.FLOWRIX_API_ORIGIN = env.ORIGIN || "";
+    runtimeConfig.FLOWRIX_API_BASE = env.BASE || "";
+    runtimeConfig.FLOWRIX_CACHE = env.CACHE || "false";
+    runtimeConfig.FLOWRIX_CDN = env.CDN || "";
+    Object.assign(runtimeConfig.public, {
+      ...runtimeConfig.public,
+      FLOWRIX_API_KEY: env.KEY || runtimeConfig.FLOWRIX_API_KEY || runtimeConfig.public.FLOWRIX_API_KEY || "",
+      FLOWRIX_API_ORIGIN: env.ORIGIN || runtimeConfig.FLOWRIX_API_ORIGIN || runtimeConfig.public.FLOWRIX_API_ORIGIN || "",
+      FLOWRIX_API_BASE: env.BASE || runtimeConfig.FLOWRIX_API_BASE || runtimeConfig.public.FLOWRIX_API_BASE || "",
+      FLOWRIX_CACHE: env.CACHE || runtimeConfig.FLOWRIX_CACHE || runtimeConfig.public.FLOWRIX_CACHE || "false",
+      FLOWRIX_CDN: env.FCDN || runtimeConfig.FLOWRIX_CDN || runtimeConfig.public.FLOWRIX_CDN || ""
+    });
     const resolver = createResolver(import.meta.url);
     await installModule("@pinia/nuxt");
+    nuxt.hook("pages:extend", (pages) => {
+      pages.push({
+        name: "default",
+        path: "/:slug(.*)",
+        file: resolver.resolve("./runtime/pages/flowrix-default.vue")
+      });
+    });
+    addPlugin({
+      src: resolver.resolve("./runtime/plugins/router")
+    });
     addServerHandler({
       middleware: true,
       handler: resolver.resolve("./runtime/utils/htmlCache")
@@ -45,6 +53,10 @@ const module = defineNuxtModule({
       route: "/api/albums",
       handler: resolver.resolve("./runtime/server/api/albums")
     });
+    addServerHandler({
+      route: "/api/reviews",
+      handler: resolver.resolve("./runtime/server/api/reviews")
+    });
     addServerHandler({
       route: "/api/banners",
       handler: resolver.resolve("./runtime/server/api/banners")
@@ -90,16 +102,20 @@ const module = defineNuxtModule({
       handler: resolver.resolve("./runtime/server/api/auth/user/verify-token")
     });
     addServerHandler({
-      route: "/api/blog/:slug",
-      handler: resolver.resolve("./runtime/server/api/blog/[slug]")
+      route: "/api/cmspost/**",
+      handler: resolver.resolve("./runtime/server/api/cmspost/[...slug]")
+    });
+    addServerHandler({
+      route: "/api/cmspost/all",
+      handler: resolver.resolve("./runtime/server/api/cmspost/all")
     });
     addServerHandler({
-      route: "/api/blog/blog",
-      handler: resolver.resolve("./runtime/server/api/blog/blog")
+      route: "/api/brand",
+      handler: resolver.resolve("./runtime/server/api/brand")
     });
     addServerHandler({
-      route: "/api/brand/:slug",
-      handler: resolver.resolve("./runtime/server/api/brand/[slug]")
+      route: "/api/brand/**",
+      handler: resolver.resolve("./runtime/server/api/brand/[...slug]")
     });
     addServerHandler({
       route: "/api/cart/remove",
@@ -117,10 +133,18 @@ const module = defineNuxtModule({
       route: "/api/cart/service/:slug/add",
       handler: resolver.resolve("./runtime/server/api/cart/service/[slug]/add")
     });
+    addServerHandler({
+      route: "/api/cart/related",
+      handler: resolver.resolve("./runtime/server/api/cart/related")
+    });
     addServerHandler({
       route: "/api/catalog/categories",
       handler: resolver.resolve("./runtime/server/api/catalog/categories")
     });
+    addServerHandler({
+      route: "/api/catalog/categories/all",
+      handler: resolver.resolve("./runtime/server/api/catalog/categoriesall")
+    });
     addServerHandler({
       route: "/api/catalog/featured",
       handler: resolver.resolve("./runtime/server/api/catalog/featured")
@@ -153,10 +177,26 @@ const module = defineNuxtModule({
       route: "/api/checkout/paymentmethod",
       handler: resolver.resolve("./runtime/server/api/checkout/paymentmethod")
     });
+    addServerHandler({
+      route: "/api/checkout/quotation/guest/:slug",
+      handler: resolver.resolve("./runtime/server/api/checkout/quotation/guest/[slug]")
+    });
+    addServerHandler({
+      route: "/api/checkout/quotation/submit/:slug",
+      handler: resolver.resolve("./runtime/server/api/checkout/quotation/submit/[slug]")
+    });
+    addServerHandler({
+      route: "/api/checkout/quotation/:slug",
+      handler: resolver.resolve("./runtime/server/api/checkout/quotation/[slug]")
+    });
     addServerHandler({
       route: "/api/company/profile",
       handler: resolver.resolve("./runtime/server/api/company/profile")
     });
+    addServerHandler({
+      route: "/api/countries",
+      handler: resolver.resolve("./runtime/server/api/countries")
+    });
     addServerHandler({
       route: "/api/contact-center/webforms/create",
       handler: resolver.resolve("./runtime/server/api/contact-center/webforms/create")
@@ -250,24 +290,48 @@ const module = defineNuxtModule({
       handler: resolver.resolve("./runtime/server/api/nav/[id]/links")
     });
     addServerHandler({
-      route: "/api/page/:slug",
-      handler: resolver.resolve("./runtime/server/api/page/[slug]")
+      route: "/api/page/**",
+      handler: resolver.resolve("./runtime/server/api/page/[...slug]")
     });
     addServerHandler({
       route: "/api/product/**",
       handler: resolver.resolve("./runtime/server/api/product/[...slug]")
     });
+    addServerHandler({
+      route: "/api/quickview/:slug",
+      handler: resolver.resolve("./runtime/server/api/quickview/[slug]")
+    });
     addServerHandler({
       route: "/api/service/:slug",
       handler: resolver.resolve("./runtime/server/api/service/[slug]")
     });
+    addServerHandler({
+      route: "/api/service/getall",
+      handler: resolver.resolve("./runtime/server/api/service/getall")
+    });
     addServerHandler({
       route: "/api/service/availability",
       handler: resolver.resolve("./runtime/server/api/service/availability")
     });
     addServerHandler({
       route: "/api/v2/**",
-      handler: resolver.resolve("./runtime/server/api/v2/[...slug]")
+      handler: resolver.resolve("./runtime/server/api/v2/[...slug].get")
+    });
+    addServerHandler({
+      route: "/api/shop",
+      handler: resolver.resolve("./runtime/server/api/shop")
+    });
+    addServerHandler({
+      route: "/api/featured",
+      handler: resolver.resolve("./runtime/server/api/featured")
+    });
+    addServerHandler({
+      route: "/api/samples",
+      handler: resolver.resolve("./runtime/server/api/samples")
+    });
+    addServerHandler({
+      route: "/api/webform",
+      handler: resolver.resolve("./runtime/server/api/webform")
     });
     addServerHandler({
       route: "/api/cache/clean",
@@ -277,7 +341,83 @@ const module = defineNuxtModule({
       route: "/api/cache/**",
       handler: resolver.resolve("./runtime/server/api/cache/[...slug].delete")
     });
+    addServerHandler({
+      route: "/sitemap.xml",
+      handler: resolver.resolve("./runtime/server/api/generate/sitemap.get")
+    });
+    addServerHandler({
+      route: "/sitemap.xml.gz",
+      handler: resolver.resolve("./runtime/server/api/generate/sitemap.get")
+    });
+    addServerHandler({
+      route: "/brands-sitemap.xml",
+      handler: resolver.resolve("./runtime/server/api/generate/sitemap.get")
+    });
+    addServerHandler({
+      route: "/brands-sitemap.xml.gz",
+      handler: resolver.resolve("./runtime/server/api/generate/sitemap.get")
+    });
+    addServerHandler({
+      route: "/post-categories-sitemap.xml",
+      handler: resolver.resolve("./runtime/server/api/generate/sitemap.get")
+    });
+    addServerHandler({
+      route: "/post-categories-sitemap.xml.gz",
+      handler: resolver.resolve("./runtime/server/api/generate/sitemap.get")
+    });
+    addServerHandler({
+      route: "/services-sitemap.xml",
+      handler: resolver.resolve("./runtime/server/api/generate/sitemap.get")
+    });
+    addServerHandler({
+      route: "/services-sitemap.xml.gz",
+      handler: resolver.resolve("./runtime/server/api/generate/sitemap.get")
+    });
+    addServerHandler({
+      route: "/pages-sitemap.xml",
+      handler: resolver.resolve("./runtime/server/api/generate/sitemap.get")
+    });
+    addServerHandler({
+      route: "/pages-sitemap.xml.gz",
+      handler: resolver.resolve("./runtime/server/api/generate/sitemap.get")
+    });
+    addServerHandler({
+      route: "/products-sitemap.xml",
+      handler: resolver.resolve("./runtime/server/api/generate/sitemap.get")
+    });
+    addServerHandler({
+      route: "/products-sitemap.xml.gz",
+      handler: resolver.resolve("./runtime/server/api/generate/sitemap.get")
+    });
+    addServerHandler({
+      route: "/posts-sitemap.xml",
+      handler: resolver.resolve("./runtime/server/api/generate/sitemap.get")
+    });
+    addServerHandler({
+      route: "/posts-sitemap.xml.gz",
+      handler: resolver.resolve("./runtime/server/api/generate/sitemap.get")
+    });
+    addServerHandler({
+      route: "/categories-sitemap.xml",
+      handler: resolver.resolve("./runtime/server/api/generate/sitemap.get")
+    });
+    addServerHandler({
+      route: "/categories-sitemap.xml.gz",
+      handler: resolver.resolve("./runtime/server/api/generate/sitemap.get")
+    });
+    addServerHandler({
+      route: "/robots.txt",
+      handler: resolver.resolve("./runtime/server/api/generate/robots.get")
+    });
+    addServerHandler({
+      route: "/api/faizancheck",
+      handler: resolver.resolve("./runtime/server/api/checkvariables")
+    });
+    addServerHandler({
+      route: "/api/check-404",
+      handler: resolver.resolve("./runtime/server/api/check-404")
+    });
   }
 });
 
-export { module as default };
+export { module$1 as default };

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

@@ -101,11 +101,8 @@ export declare const useBlogIndex: () => {
     loadMore: () => Promise<void>;
     clearSearch: () => void;
     fetchBlogData: () => Promise<{
-        data: import("vue").Ref<BlogData | undefined, BlogData | undefined>;
-        pending: import("vue").Ref<boolean, boolean>;
-    } | {
-        data: import("vue").Ref<null, null>;
-        pending: import("vue").Ref<boolean, boolean>;
+        data: any;
+        pending: any;
     }>;
 };
 export {};

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

@@ -1,16 +1,14 @@
 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,
+      CardImg: "",
       CardTitle: "What is Matter Technology and Why Does it Matter?"
     },
     {
-      CardImg: magazineImg2,
+      CardImg: "",
       CardTitle: "Easily convert your existing roller blinds into smart shades"
     }
   ]);

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

@@ -1,6 +1,6 @@
 export declare function useBrand(template: {
     template: string;
-}): {
+}, ProductTypes?: never[]): {
     Brandtemplate: any;
     brandData: any;
     pending: any;

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

@@ -1,5 +1,6 @@
 import { defineAsyncComponent, watch } from "vue";
-export function useBrand(template) {
+import { useRoute, useFetch } from "#imports";
+export function useBrand(template, ProductTypes = []) {
   const route = useRoute();
   const components = import.meta.glob(
     "~/components/Brand/Template*/**/index.vue"
@@ -18,8 +19,30 @@ export function useBrand(template) {
     }
   });
   const slug = route.params.slug;
-  const query = route.query;
+  let query = {
+    ...route.query
+  };
+  if (ProductTypes.includes("parentsonly")) {
+    query.parentsonly = "true";
+  }
+  if (ProductTypes.includes("directproducts")) {
+    query.directproducts = "true";
+  }
+  if (ProductTypes.includes("custom")) {
+    query.custom = "true";
+  }
+  if (ProductTypes.includes("simple")) {
+    query.simple = "true";
+  }
+  if (ProductTypes.includes("bundle")) {
+    query.bundle = "true";
+  }
+  if (ProductTypes.includes("sample")) {
+    query.sample = "true";
+  }
+  query.ProductTypes = ["custom", "simple", "bundle", "sample"];
   const { data: brandData, error, pending, refresh } = useFetch(`/api/brand/${slug}`, {
+    method: "post",
     query
   });
   watch(brandData, (newData) => {

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

@@ -0,0 +1,40 @@
+export 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;
+    };
+}
+export interface CartDetailProps {
+    items: Record<string, Product>;
+}
+export declare const useCartDetail: (props: CartDetailProps) => Promise<{
+    response: any;
+}>;

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

@@ -0,0 +1,10 @@
+export const useCartDetail = async (props) => {
+  const apiUrl = `/api/cart/related`;
+  const response = await $fetch(apiUrl, {
+    method: "POST",
+    body: props
+  });
+  return {
+    response
+  };
+};

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

@@ -0,0 +1 @@
+export declare const useCartComponent: () => Promise<void>;

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

@@ -0,0 +1,11 @@
+import { useCartStore } from "../../stores/Cart.js";
+import { GTM_view_cart } from "../useDataLayer.js";
+import { META_view_cart } from "../useMetaLayer.js";
+import { TikTok_view_cart } from "../useTikTokDatalayer.js";
+export const useCartComponent = async () => {
+  const cartStore = useCartStore();
+  const cart = cartStore.cart;
+  GTM_view_cart(cart);
+  META_view_cart(cart);
+  TikTok_view_cart(cart);
+};

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

@@ -1,4 +1,4 @@
-interface Product {
+export interface Product {
     name: string;
     height?: number;
     width?: number;
@@ -32,18 +32,28 @@ interface Product {
         per_order_pricing: number;
     };
 }
-interface CartDetailProps {
+export 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>;
+    companyProfile: null;
+    checkoutData: import("vue").ComputedRef<{
+        [x: string]: any;
+        preferences?: Record<string, any>[] | undefined;
+        outlets?: Record<string, any>[] | undefined;
+        deliverytype?: string | undefined;
+        order_no?: string | undefined;
+        publishableKey?: any;
+        calculations?: any;
+        shippingmethods?: any;
+        cart?: Record<string, import("../../stores/Checkout.js").CartItem> | undefined;
+        totals?: Record<string, any> | undefined;
+    }>;
     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

@@ -1,4 +1,7 @@
 import { onMounted, ref, computed } from "vue";
+import { useCartStore } from "../../stores/Cart.js";
+import { useCompanyProfile } from "../../stores/useCompanyProfile.js";
+import { useCheckoutStore } from "../../stores/Checkout.js";
 export const useCartDetail = (props) => {
   const cartStore = useCartStore();
   const { profile: companyProfile } = useCompanyProfile();

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

@@ -1,33 +1,26 @@
-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;
+export declare const useCategoryIndex: (props: any, ProductTypes?: never[]) => {
+    catData: any;
+    pending: any;
+    error: any;
+    transformedApiData: import("vue").ComputedRef<{
+        status: any;
+        message: any;
+        data: {
+            template: any;
+            type: any;
+            record: {
+                category: any;
+                products: any;
+                brands: any;
+                filter_values: any;
+                filters: any;
+                categories: any;
+                prices: any;
+                breadcrumb: any;
+            };
         };
-    };
-}
-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 {};
+    } | null>;
+    renderData: import("vue").ComputedRef<any>;
+    refresh: any;
+    getSelectedTemplate: (templateComponents: any) => import("vue").ComputedRef<any>;
+};