flowrix 1.0.1-beta.155 → 1.0.1-beta.157

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/useLocation.d.ts

@@ -17,7 +17,7 @@ interface LocationData {
     region_id?: number;
     zip_code?: string;
 }
-export declare function useLocation(): {
+export declare function useLocation(defaultLocation: any): {
     states: import("vue").Ref<never[], never[]>;
     manualLocationHeading: import("vue").Ref<string | null, string | null>;
     locationInputs: import("vue").Ref<{
@@ -33,22 +33,10 @@ export declare function useLocation(): {
         region: string;
         region_id: string | number | null;
     }>;
-    location: import("vue").ComputedRef<{
-        city?: string | undefined;
-        country_name?: string | undefined;
-        country_code?: string | undefined;
-        country_id?: number | undefined;
-        ip?: string | undefined;
-        proxy?: boolean | undefined;
-        region?: string | undefined;
-        region_short?: string | undefined;
-        region_id?: number | undefined;
-        zip_code?: string | undefined;
-    } | null>;
+    location: import("vue").ComputedRef<any>;
     countries: import("vue").ComputedRef<any>;
-    loading: import("vue").ComputedRef<boolean>;
+    loading: import("vue").ComputedRef<any>;
     companyCountryId: import("vue").ComputedRef<any>;
-    getStateShort: (stateName: string) => string;
     getStates: (countryId: number | string) => any;
     changeStates: (selectedCountry: string | number) => void;
     changeLocation: (data?: Partial<LocationInputs>) => Promise<void>;

package/dist/runtime/composables/useLocation.js

@@ -1,22 +1,15 @@
 import { ref, computed, watch, nextTick } from "vue";
-import { useIpLocation } from "../stores/IpLocation.js";
 import { useCountriesStore } from "../stores/countries.js";
 import { useCompanyProfile } from "../stores/useCompanyProfile.js";
 import { useCheckoutStore } from "../stores/Checkout.js";
-export function useLocation() {
-  const locationStore = useIpLocation();
+export function useLocation(defaultLocation) {
+  const locationStore = useLocationsStore();
   const countriesStore = useCountriesStore();
   const companyProfileStore = useCompanyProfile();
   const checkoutStore = useCheckoutStore();
   const states = ref([]);
   const manualLocationHeading = ref(null);
-  const locationInputs = ref({
-    country: "Australia",
-    country_id: 14,
-    zip_code: 3370,
-    region: "",
-    region_id: null
-  });
+  const locationInputs = ref(defaultLocation);
   const location = computed(() => locationStore.location);
   const countries = computed(() => {
     const storeCountries = countriesStore.countries;
@@ -30,19 +23,6 @@ export function useLocation() {
   const loading = computed(() => locationStore.loading);
   const profile = computed(() => companyProfileStore.profile);
   const companyCountryId = computed(() => profile.value?.country_id || 14);
-  const stateShortCodes = {
-    "New South Wales": "NSW",
-    "Victoria": "VIC",
-    "Queensland": "QLD",
-    "South Australia": "SA",
-    "Western Australia": "WA",
-    "Tasmania": "TAS",
-    "Northern Territory": "NT",
-    "Australian Capital Territory": "ACT"
-  };
-  const getStateShort = (stateName) => {
-    return stateShortCodes[stateName] || stateName;
-  };
   const getStates = (countryId) => {
     if (!countries.value || countries.value.length === 0) {
       console.warn("No countries available");
@@ -107,13 +87,13 @@ export function useLocation() {
       const newLocation = {
         zip_code: updateData.zip_code,
         region: state.name,
-        region_short: getStateShort(state.name),
+        region_short: state.state_code,
         region_id: state.id,
         country_name: country.name,
         country_id: country.id
       };
-      locationStore.location = newLocation;
-      checkoutStore.saveToCheckoutSession(newLocation, "changelocation");
+      locationStore.setLocation(newLocation);
+      console.log("newLocation", locationStore);
     } catch (error) {
       console.error("Error updating location:", error);
     }
@@ -341,7 +321,6 @@ export function useLocation() {
     loading,
     companyCountryId,
     // Methods
-    getStateShort,
     getStates,
     changeStates,
     changeLocation,

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

@@ -0,0 +1,33 @@
+export interface Promotion {
+    id: number;
+    labels: string | null;
+    voucherdiscounttype_id: number;
+    discounttype: number;
+    discount: number;
+    sortorder: number;
+    start_date: string | null;
+    end_date: string | null;
+    date_range_schedule: number;
+    day_time_schedule: number;
+    voucherschedule: Array<{
+        day: number;
+        start_time: string | null;
+        end_time: string | null;
+    }>;
+    includecustomers: number[];
+    includecustomertypes: number[];
+    includeproducts: number[];
+    includeoutlets: number[];
+}
+export interface PriceCalculationResult {
+    finalPrice: number;
+    originalPrice: number;
+    totalDiscount: number;
+    hasDiscount: boolean;
+    appliedPromotions: Promotion[];
+}
+export declare const usePriceCalculation: () => {
+    calculatePrice: (productId: number, price: number, promotions: Promotion[]) => PriceCalculationResult;
+    filterPromotions: (promotions: Promotion[], productId: number, customerTypeId?: number) => Promotion[];
+    calculateDiscount: (price: number, filteredPromotions: Promotion[]) => number;
+};

package/dist/runtime/composables/usePriceCalculation.js

@@ -0,0 +1,107 @@
+export const usePriceCalculation = () => {
+  const getCurrentDateUTC = () => {
+    const now = /* @__PURE__ */ new Date();
+    return now.toISOString().split("T")[0];
+  };
+  const getCurrentTimeUTC = () => {
+    const now = /* @__PURE__ */ new Date();
+    return now.toISOString().split("T")[1].split(".")[0];
+  };
+  const getISODayUTC = () => {
+    const now = /* @__PURE__ */ new Date();
+    const day = now.getUTCDay();
+    return day === 0 ? 7 : day;
+  };
+  const filterPromotions = (promotions, productId, customerTypeId = 1) => {
+    if (!promotions || !Array.isArray(promotions)) {
+      return [];
+    }
+    const currentDate = getCurrentDateUTC();
+    const currentTime = getCurrentTimeUTC();
+    const dayOfWeek = getISODayUTC();
+    return promotions.filter((p) => p.discounttype === 3).filter((p) => p.includeproducts.length === 0 || p.includeproducts.includes(productId)).filter((p) => {
+      if (p.includecustomertypes.length === 0) return true;
+      const isAllowed = p.includecustomertypes.includes(customerTypeId);
+      if (import.meta.client) {
+        console.log("Customer Type Filter:", {
+          promotionId: p.id,
+          includecustomertypes: p.includecustomertypes,
+          customerTypeId,
+          isAllowed
+        });
+      }
+      return isAllowed;
+    }).filter((p) => {
+      if (p.date_range_schedule === 0 || !p.start_date && !p.end_date) return true;
+      if (p.date_range_schedule === 1) {
+        if (p.start_date && !p.end_date) return currentDate >= p.start_date;
+        if (!p.start_date && p.end_date) return currentDate <= p.end_date;
+        if (p.start_date && p.end_date) {
+          return currentDate >= p.start_date && currentDate <= p.end_date;
+        }
+      }
+      return false;
+    }).filter((p) => {
+      if (p.day_time_schedule === 0 || p.voucherschedule.length === 0) return true;
+      const daySchedules = p.voucherschedule.filter((s) => s.day === dayOfWeek);
+      if (daySchedules.length === 0) return false;
+      return daySchedules.some((s) => {
+        if (!s.start_time && !s.end_time) return true;
+        if (s.start_time && !s.end_time) return currentTime >= s.start_time;
+        if (!s.start_time && s.end_time) return currentTime <= s.end_time;
+        if (s.start_time && s.end_time) {
+          return currentTime >= s.start_time && currentTime <= s.end_time;
+        }
+        return false;
+      });
+    }).sort((a, b) => b.sortorder - a.sortorder);
+  };
+  const calculateDiscount = (price, filteredPromotions) => {
+    const fixedDiscounts = filteredPromotions.filter((p) => p.voucherdiscounttype_id === 3).reduce((sum, p) => sum + p.discount, 0);
+    const percentageDiscounts = Math.min(
+      filteredPromotions.filter((p) => p.voucherdiscounttype_id === 2).reduce((sum, p) => sum + p.discount, 0),
+      100
+    );
+    const percentageAmount = percentageDiscounts / 100 * price;
+    const totalDiscount = fixedDiscounts + percentageAmount;
+    return Math.min(totalDiscount, price);
+  };
+  const calculatePrice = (productId, price, promotions) => {
+    const customerTypeCookie = useCookie("customer_type");
+    let customerTypeId = 1;
+    if (customerTypeCookie.value) {
+      const parsed = parseInt(customerTypeCookie.value);
+      customerTypeId = isNaN(parsed) ? 1 : parsed;
+    }
+    if (import.meta.client) {
+      console.log("Price Calculation Debug:", {
+        productId,
+        customerTypeId,
+        cookieValue: customerTypeCookie.value,
+        promotionsCount: promotions.length
+      });
+    }
+    const filteredPromotions = filterPromotions(promotions, productId, customerTypeId);
+    if (import.meta.client) {
+      console.log("Filtered Promotions:", {
+        total: promotions.length,
+        filtered: filteredPromotions.length,
+        promotions: filteredPromotions
+      });
+    }
+    const discount = calculateDiscount(price, filteredPromotions);
+    const finalPrice = Math.max(price - discount, 0);
+    return {
+      finalPrice: Math.round(finalPrice * 100) / 100,
+      originalPrice: price,
+      totalDiscount: Math.round(discount * 100) / 100,
+      hasDiscount: discount > 0,
+      appliedPromotions: filteredPromotions
+    };
+  };
+  return {
+    calculatePrice,
+    filterPromotions,
+    calculateDiscount
+  };
+};

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

@@ -74,5 +74,5 @@ export declare const useQuotationCheckout: () => {
     getGuestQuotation: (slug: string, query?: any) => Promise<any>;
     GuestCheckoutQuotation: (slug: string, quotationData: any, query?: any) => Promise<any>;
     paymentMethods: (formData: any) => Promise<any>;
-    submitCheckout: (slug: string, quotationData: any) => Promise<unknown>;
+    submitCheckout: (slug: string, quotationData: any) => Promise<any>;
 };

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

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

@@ -32,16 +32,16 @@ async function request(method, config = {}, endpoint, options = {}) {
     ...options.headers
   };
   try {
+    console.log("headers headers headers headers", headers);
     const response = await $fetch(`${FLOWRIX_API_BASE}${endpoint}`, {
       method,
       ...options,
       headers,
       onResponse({ response: response2 }) {
-        console.log(response2);
         const token = response2.headers.get("x-session-token");
         if (token) {
           if (process.client) {
-            document.cookie = `x-session-token=${token}; path=/; max-age=3600; secure; SameSite=Lax`;
+            document.cookie = `x-session-token=${token}; path=/; max-age=2592000; secure; SameSite=Lax`;
           }
         }
       }

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

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

package/dist/runtime/middleware/flowrixs3.js

@@ -0,0 +1,65 @@
+let S3Client = null;
+let GetObjectCommand = null;
+async function loadAWSSDK() {
+  if (!S3Client) {
+    const sdk = await import("@aws-sdk/client-s3");
+    S3Client = sdk.S3Client;
+    GetObjectCommand = sdk.GetObjectCommand;
+  }
+}
+let s3Client = null;
+async function getClient(config = {}) {
+  await loadAWSSDK();
+  if (s3Client) return s3Client;
+  const region = config?.S3_REGION || config.public?.S3_REGION || "us-east-1";
+  const accessKeyId = config?.S3_ACCESS_KEY_ID || "";
+  const secretAccessKey = config?.S3_SECRET_ACCESS_KEY || "";
+  const clientConfig = { region };
+  if (accessKeyId && secretAccessKey) {
+    clientConfig.credentials = {
+      accessKeyId,
+      secretAccessKey
+    };
+  }
+  s3Client = new S3Client(clientConfig);
+  return s3Client;
+}
+async function streamToString(stream) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+async function request(config = {}, endpoint, options = {}) {
+  await loadAWSSDK();
+  const client = await getClient(config);
+  const bucket = config.S3_BUCKET || "";
+  const TENANT = config.S3_TENANT || "";
+  let key = "";
+  if (options.filetype && options.filetype == true) {
+    key = TENANT + "/" + endpoint;
+  } else {
+    key = TENANT + "/" + endpoint + ".json";
+  }
+  const command = new GetObjectCommand({ Bucket: bucket, Key: key });
+  try {
+    const start = Date.now();
+    const response = await client.send(command);
+    const body = await streamToString(response.Body);
+    const fetchTimeMs = Date.now() - start;
+    const fixed = body;
+    if (response.ContentType == "application/json") {
+      const parsed = JSON.parse(fixed);
+      parsed.fetchTimeMs = fetchTimeMs;
+      return parsed;
+    } else {
+      return fixed;
+    }
+  } catch (error) {
+    throw error;
+  }
+}
+export const flowrixS3 = {
+  get: (endpoint, config = {}, options = {}) => request(config, endpoint, options)
+};

package/dist/runtime/pages/flowrix-default.vue

@@ -1,39 +1,61 @@
 <script setup>
 import { useRoute } from "vue-router";
 import { defineAsyncComponent, computed } from "vue";
+import { setResponseStatus, setHeader } from "h3";
+const event = useRequestEvent();
+import { usePromotions } from "../stores/promotions";
 const DynamicContent = defineAsyncComponent(() => import("../components/Types/dynamic.vue"));
+const Category = defineAsyncComponent(() => import("@/components/Category/index.vue"));
+const Product = defineAsyncComponent(() => import("@/components/Product/index.vue"));
+const BlogSingle = defineAsyncComponent(() => import("@/components/blog/single.vue"));
+const PageComponent = defineAsyncComponent(() => import("@/components/pages/index.vue"));
+const cmsCategory = defineAsyncComponent(() => import("@/components/cmscategory/index.vue"));
+const Brand = defineAsyncComponent(() => import("@/components/Brand/index.vue"));
 const route = useRoute();
 const slug = route.params.slug || "home";
-const { data, error } = await useFetch(`/api/v2/${slug}`);
+const { data, error } = await useFetch(`/api/permalink/${slug}`, {
+  server: true,
+  lazy: false
+});
+if (import.meta.server && error.value) {
+  const statusCode = error.value.statusCode || 500;
+  setResponseStatus(event, statusCode);
+  setHeader(
+    event,
+    "Cache-Control",
+    "public, max-age=0, s-maxage=0, must-revalidate"
+  );
+}
 const redirectPage = (async (redirectData) => {
   return navigateTo(`/${redirectData.target}`, { redirectCode: redirectData.status_code || 404 });
 });
-if (data.value?.data?.type === "redirect") {
-  redirectPage(data.value?.data);
-}
-if (error.value || !data.value?.data) {
-  throw createError({ statusCode: 404, message: "Page Not Found" });
+if (data.value?.permalink?.type === "redirect") {
+  redirectPage(data.value?.permalink);
 }
 useHead({
   style: [
     {
-      innerHTML: data.value?.data?.content?.css || "",
+      innerHTML: data.value?.permalink?.content?.css || "",
       type: "text/css"
     }
   ]
 });
 const DynamicComponent = computed(() => {
-  const type = data.value?.data?.type;
+  const type = data.value?.permalink?.type;
   if (!type || type === "redirect") {
     return null;
   }
   return defineAsyncComponent(
-    () => import(`../components/Types/${type}/index.vue`).catch(() => import("./404.vue"))
+    () => import(`@/components/Types/${type}/index.vue`).catch(
+      () => import(`../components/Types/${type}/index.vue`)
+    ).catch(
+      () => import("./404.vue")
+    )
   );
 });
 const NotFoundComponent = defineAsyncComponent(async () => {
-  const project404 = import.meta.glob("~/pages/404.vue");
-  const projectKey = "/pages/404.vue";
+  const project404 = import.meta.glob("~/components/404.vue");
+  const projectKey = "/components/404.vue";
   if (projectKey && project404[projectKey]) {
     return project404[projectKey]();
   }
@@ -49,14 +71,39 @@ const NotFoundComponent = defineAsyncComponent(async () => {
 </script>
 
 <template>
+  <template v-if="data && data.permalink.is_dynamic == true">
   <template v-if="data && DynamicComponent">
-    <component :is="DynamicComponent" :data="data?.data" />
+    <component :is="DynamicComponent" :data="data.data" />
   </template>
-  <template v-else>
-    <ClientOnly>    
+  <template v-else>   
       <NotFoundComponent/>
-    </ClientOnly>
   </template>
+  </template><!-- end is dynamic true-->
+  <template v-else>
+   <template v-if="data && data?.permalink.type == 'product'">
+            <Product :product="data" />
+        </template>
+        <template v-if="data && data?.permalink.type == 'page'">       
+            <PageComponent v-if="data" :pageData="data?.data" />
+        </template>
+        <template v-if="data && data?.permalink.type == 'brand'">
+            <Brand v-if="data" :data="data?.data" />
+        </template>
+        <template v-if="data && data?.permalink.type == 'category'">
+            <Category :data="data?.data"/>
+        </template>
+        <template v-if="data && data?.permalink.type == 'post'">
+            <div class="container-fluid px-xl-5 px-0">
+                <BlogSingle :data="data?.data" />
+            </div>
+        </template>
+        <template v-if="data && data?.permalink.type == 'cmscategory'">
+            <div class="container-fluid px-xl-5 px-4">
+                <cmsCategory :data="data?.data" />
+            </div>
+        </template>
+  </template>
+  <component v-if="error" :is="NotFoundComponent"/>
 </template>
 
 <style>

package/dist/runtime/plugins/full-reload.client.d.ts

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