flowrix 1.0.1-beta.14 → 1.0.1-beta.141

package/dist/runtime/stores/wishlists.d.ts

@@ -1,28 +1,145 @@
 export interface Wishlist {
     id: number;
-    name?: string;
+    title: string;
+    default: boolean;
+    created_at: string;
 }
 export interface WishlistProduct {
     id: number;
-    productSlug: string;
+    slug: string;
+    item_id: string;
+    name: string;
+    image: string;
+    price: string;
+    pricefloat: number;
+    rp: string;
+    rpfloat: number;
+    type: string;
+    brandimage: string;
+    options?: any;
 }
 export interface WishlistProducts {
     [listId: number]: WishlistProduct[];
 }
+export interface CreateWishlistData {
+    title: string;
+    default: boolean;
+}
+export interface UpdateWishlistData {
+    title: string;
+    default: boolean;
+}
+export interface AddToWishlistData {
+}
+export interface ApiResponse<T> {
+    status: string;
+    message: string | Record<string, string[]> | null;
+    data: T | null;
+}
 export declare const useWishlistsStore: import("pinia").StoreDefinition<"wishlists", {
     wishlists: Wishlist[];
     wishlistProducts: WishlistProducts;
     loading: boolean;
     error: string | null;
-}, {}, {
+    productVersions: Record<number, number>;
+}, {
+    getWishlists: (state: {
+        wishlists: {
+            id: number;
+            title: string;
+            default: boolean;
+            created_at: string;
+        }[];
+        wishlistProducts: WishlistProducts;
+        loading: boolean;
+        error: string | null;
+        productVersions: Record<number, number>;
+    } & import("pinia").PiniaCustomStateProperties<{
+        wishlists: Wishlist[];
+        wishlistProducts: WishlistProducts;
+        loading: boolean;
+        error: string | null;
+        productVersions: Record<number, number>;
+    }>) => {
+        id: number;
+        title: string;
+        default: boolean;
+        created_at: string;
+    }[];
+    getWishlistProducts: (state: {
+        wishlists: {
+            id: number;
+            title: string;
+            default: boolean;
+            created_at: string;
+        }[];
+        wishlistProducts: WishlistProducts;
+        loading: boolean;
+        error: string | null;
+        productVersions: Record<number, number>;
+    } & import("pinia").PiniaCustomStateProperties<{
+        wishlists: Wishlist[];
+        wishlistProducts: WishlistProducts;
+        loading: boolean;
+        error: string | null;
+        productVersions: Record<number, number>;
+    }>) => (listId: number) => WishlistProduct[];
+    isLoading: (state: {
+        wishlists: {
+            id: number;
+            title: string;
+            default: boolean;
+            created_at: string;
+        }[];
+        wishlistProducts: WishlistProducts;
+        loading: boolean;
+        error: string | null;
+        productVersions: Record<number, number>;
+    } & import("pinia").PiniaCustomStateProperties<{
+        wishlists: Wishlist[];
+        wishlistProducts: WishlistProducts;
+        loading: boolean;
+        error: string | null;
+        productVersions: Record<number, number>;
+    }>) => boolean;
+    getError: (state: {
+        wishlists: {
+            id: number;
+            title: string;
+            default: boolean;
+            created_at: string;
+        }[];
+        wishlistProducts: WishlistProducts;
+        loading: boolean;
+        error: string | null;
+        productVersions: Record<number, number>;
+    } & import("pinia").PiniaCustomStateProperties<{
+        wishlists: Wishlist[];
+        wishlistProducts: WishlistProducts;
+        loading: boolean;
+        error: string | null;
+        productVersions: Record<number, number>;
+    }>) => string | null;
+}, {
+    setLoading(loading: boolean): void;
+    setError(error: string | null): void;
     setWishlists(wishlists: Wishlist[]): void;
     addWishlist(wishlist: Wishlist): void;
-    updateWishlist(updatedWishlist: Wishlist): void;
-    removeWishlist(id: number): void;
+    removeWishlist(wishlistId: number): void;
     setWishlistProducts(listId: number, products: WishlistProduct[]): void;
     addWishlistProduct(listId: number, product: WishlistProduct): void;
-    removeWishlistProduct(listId: number, productSlug: string): void;
     clearWishlistProducts(listId: number): void;
-    setLoading(loading: boolean): void;
-    setError(error: string | null): void;
+    fetchWishlists(force?: boolean): 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, itemId: string): Promise<ApiResponse<void>>;
+    updateWishlist(id: number, data: UpdateWishlistData): Promise<ApiResponse<Wishlist>>;
+    deleteWishlist(id: number): Promise<ApiResponse<void>>;
 }>;

package/dist/runtime/stores/wishlists.js

@@ -1,49 +1,241 @@
 import { defineStore } from "pinia";
+import { flowrixApi } from "../middleware/flowrix.js";
+import { useRuntimeConfig } from "#imports";
 export const useWishlistsStore = defineStore("wishlists", {
   state: () => ({
     wishlists: [],
     wishlistProducts: {},
     loading: false,
-    error: null
+    error: null,
+    productVersions: {}
   }),
   actions: {
+    setLoading(loading) {
+      this.loading = loading;
+    },
+    setError(error) {
+      this.error = error;
+    },
     setWishlists(wishlists) {
       this.wishlists = wishlists;
     },
     addWishlist(wishlist) {
-      this.wishlists.unshift(wishlist);
-    },
-    updateWishlist(updatedWishlist) {
-      const index = this.wishlists.findIndex((w) => w.id === updatedWishlist.id);
-      if (index !== -1) {
-        this.wishlists[index] = updatedWishlist;
-      }
+      this.wishlists.push(wishlist);
     },
-    removeWishlist(id) {
-      this.wishlists = this.wishlists.filter((w) => w.id !== id);
+    removeWishlist(wishlistId) {
+      this.wishlists = this.wishlists.filter((w) => w.id !== wishlistId);
+      delete this.productVersions[wishlistId];
     },
     setWishlistProducts(listId, products) {
       this.wishlistProducts[listId] = products;
+      this.productVersions[listId] = (this.productVersions[listId] || 0) + 1;
     },
     addWishlistProduct(listId, product) {
       if (!this.wishlistProducts[listId]) {
         this.wishlistProducts[listId] = [];
       }
-      this.wishlistProducts[listId].unshift(product);
-    },
-    removeWishlistProduct(listId, productSlug) {
-      if (this.wishlistProducts[listId]) {
-        this.wishlistProducts[listId] = this.wishlistProducts[listId].filter((p) => p.productSlug !== productSlug);
-      }
+      this.wishlistProducts[listId].push(product);
+      this.productVersions[listId] = (this.productVersions[listId] || 0) + 1;
     },
     clearWishlistProducts(listId) {
       delete this.wishlistProducts[listId];
+      delete this.productVersions[listId];
     },
-    setLoading(loading) {
-      this.loading = loading;
+    // Fetch all wishlists
+    async fetchWishlists(force = false) {
+      if (!force && this.wishlists.length > 0) {
+        return {
+          status: "Success",
+          data: this.wishlists,
+          message: null
+        };
+      }
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = "mystore/customer/wishlist";
+        const response = await flowrixApi.get(apiUrl, apiConfig, {});
+        if (response.status === "Success") {
+          this.setWishlists(response.data || []);
+          return response;
+        } else {
+          return response;
+        }
+      } catch (error) {
+        return error.data;
+      }
     },
-    setError(error) {
-      this.error = error;
+    async fetchWishlistProducts(listId) {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = `mystore/customer/wishlist/${listId}/products`;
+        const response = await flowrixApi.get(apiUrl, apiConfig, {});
+        if (response.status === "Success" && response.data) {
+          const products = response.data.products || [];
+          this.setWishlistProducts(listId, products);
+          return response;
+        } else {
+          return response;
+        }
+      } catch (error) {
+        console.error("[Store] Error fetching wishlist products:", error);
+        return error.data;
+      }
+    },
+    // Create a new wishlist
+    async createWishlist(data) {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = "mystore/customer/wishlist/add";
+        const response = await flowrixApi.post(apiUrl, apiConfig, {
+          body: data
+        });
+        if (response.status === "Success") {
+          await this.fetchWishlists(true);
+          return response;
+        } else {
+          return response;
+        }
+      } catch (error) {
+        return error.data;
+      }
+    },
+    // Add product to wishlist
+    async addToWishlist(listId, productSlug, data = {}) {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = `mystore/customer/wishlist/${listId}/${productSlug}/add`;
+        const response = await flowrixApi.post(apiUrl, apiConfig, {
+          body: data
+        });
+        if (response.status === "Success" && response.data) {
+          this.addWishlistProduct(listId, response.data);
+          return response;
+        } else {
+          return response;
+        }
+      } catch (error) {
+        return error.data;
+      }
+    },
+    async removeFromWishlist(listId, itemId) {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = `mystore/customer/wishlist/${listId}/item/delete`;
+        const response = await flowrixApi.post(apiUrl, apiConfig, {
+          body: { ids: { productSlug: itemId } }
+        });
+        console.log("[Store] Remove API response:", response.status);
+        if (response.status === "Success") {
+          return response;
+        } else {
+          return response;
+        }
+      } catch (error) {
+        console.error("[Store] Error in removeFromWishlist:", error);
+        return error.data;
+      }
+    },
+    // Update wishlist
+    async updateWishlist(id, data) {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = `mystore/customer/wishlist/${id}/update`;
+        const response = await flowrixApi.post(apiUrl, apiConfig, {
+          body: data
+        });
+        if (response.status === "Success") {
+          await this.fetchWishlists(true);
+          return response;
+        } else {
+          return response;
+        }
+      } catch (error) {
+        return error.data;
+      }
+    },
+    // Delete wishlist
+    async deleteWishlist(id) {
+      try {
+        const config = useRuntimeConfig();
+        let rawCookies = "";
+        if (process.client) {
+          rawCookies = document.cookie || "";
+        }
+        const apiConfig = {
+          ...config,
+          cookies: rawCookies
+        };
+        const apiUrl = `mystore/customer/wishlist/${id}/delete`;
+        const response = await flowrixApi.post(apiUrl, apiConfig, {
+          body: {}
+        });
+        if (response.status === "Success") {
+          this.removeWishlist(id);
+          this.clearWishlistProducts(id);
+          return response;
+        } else {
+          return response;
+        }
+      } catch (error) {
+        return error.data;
+      }
     }
+  },
+  getters: {
+    getWishlists: (state) => state.wishlists,
+    getWishlistProducts: (state) => (listId) => {
+      const version = state.productVersions[listId] || 0;
+      return state.wishlistProducts[listId] || [];
+    },
+    isLoading: (state) => state.loading,
+    getError: (state) => state.error
   }
 });

package/dist/runtime/utils/api.js

@@ -1,3 +1,5 @@
+import { useRuntimeConfig } from "nuxt/app";
+import { useCookie } from "nuxt/app";
 import { useAuthStore } from "../stores/auth.js";
 function getLocationHeaders() {
   const headers = {};
@@ -32,26 +34,18 @@ function getLocationHeaders() {
   }
   return headers;
 }
-function getEnv(key) {
-  if (typeof useRuntimeConfig === "function") {
-    const config = useRuntimeConfig();
-    return config.public?.[key] || config[key];
-  }
-  return process.env[key];
-}
 export function useApi() {
   const authStore = useAuthStore();
-  const FLOWRIX_API_KEY = getEnv("FLOWRIX_API_KEY");
-  const FLOWRIX_API_SECRET = getEnv("FLOWRIX_API_SECRET");
-  const FLOWRIX_API_ORIGIN = getEnv("FLOWRIX_API_ORIGIN");
-  const FLOWRIX_API_BASE = getEnv("FLOWRIX_API_BASE");
+  const config = useRuntimeConfig();
+  const FLOWRIX_API_KEY = config.FLOWRIX_API_KEY;
+  const FLOWRIX_API_ORIGIN = config.FLOWRIX_API_ORIGIN;
+  const FLOWRIX_API_BASE = config.FLOWRIX_API_BASE;
   const baseURL = FLOWRIX_API_BASE || "";
   async function request(method, url, data = null, options = {}, extraHeaders = {}) {
     const locationHeaders = getLocationHeaders();
     const headers = {
       "Content-Type": "application/json",
-      "X-API-Key": FLOWRIX_API_KEY,
-      "X-API-Secret": FLOWRIX_API_SECRET,
+      "x-public-key": FLOWRIX_API_KEY,
       // Add location headers from cookies
       ...locationHeaders,
       // Add extra headers

package/dist/runtime/utils/htmlCache.d.ts

@@ -1,5 +1,5 @@
-export declare function readCache(pathname: string): Promise<string | null>;
-export declare function writeCache(pathname: string, html: string): Promise<void>;
+export declare function readCache(url: URL, customerType: number): Promise<string | null>;
+export declare function writeCache(url: URL, html: string, customerType: number): Promise<void>;
 export declare function clearCache(): Promise<void>;
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string | undefined>>;
 export default _default;

package/dist/runtime/utils/htmlCache.js

@@ -1,27 +1,34 @@
 import { promises as fs } from "fs";
 import { join } from "path";
-import { getRequestURL } from "h3";
-import { defineEventHandler } from "h3";
-const cacheDir = join(process.cwd(), ".nuxt", "cache", "html");
+import { getRequestURL, defineEventHandler, getCookie } from "h3";
+import { useRuntimeConfig } from "#imports";
+const cacheDir = join("/tmp", ".cache", "html");
 async function ensureDir() {
   await fs.mkdir(cacheDir, { recursive: true });
 }
-function getCacheFilePath(pathname) {
-  const safeName = pathname.replace(/[^a-zA-Z0-9-_]/g, "_") || "index";
-  return join(cacheDir, `${safeName}-__.html`);
+function getCacheFilePath(url, customerType) {
+  const { pathname, searchParams } = url;
+  const queryObj = {};
+  for (const [key, value] of searchParams.entries()) {
+    queryObj[key] = value;
+  }
+  const queryString = Object.keys(queryObj).length ? `_${JSON.stringify(queryObj)}` : "";
+  const cacheKey = `${pathname}${queryString}`;
+  const safeName = cacheKey.replace(/[^a-zA-Z0-9-_]/g, "_") || "index";
+  return join(cacheDir, `${safeName}-__-${customerType}.html`);
 }
-export async function readCache(pathname) {
+export async function readCache(url, customerType) {
   try {
-    const filePath = getCacheFilePath(pathname);
+    const filePath = getCacheFilePath(url, customerType);
     const html = await fs.readFile(filePath, "utf8");
     return html;
   } catch {
     return null;
   }
 }
-export async function writeCache(pathname, html) {
+export async function writeCache(url, html, customerType) {
   await ensureDir();
-  const filePath = getCacheFilePath(pathname);
+  const filePath = getCacheFilePath(url, customerType);
   await fs.writeFile(filePath, html, "utf8");
 }
 export async function clearCache() {
@@ -33,9 +40,10 @@ export async function clearCache() {
 }
 export default defineEventHandler(async (event) => {
   const url = getRequestURL(event);
-  const pathname = url.pathname;
+  const config = useRuntimeConfig();
+  const customerType = getCookie(event, "customertype") || 1;
   if (event.method !== "GET" || !event.headers.get("accept")?.includes("text/html")) return;
-  const cached = await readCache(pathname);
+  const cached = await readCache(url, customerType);
   if (cached) {
     event.node.res.setHeader("x-cache", "HIT");
     return cached;
@@ -46,7 +54,9 @@ export default defineEventHandler(async (event) => {
     if (chunk) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
     const html = Buffer.concat(chunks).toString("utf-8");
     if (event.node.res.statusCode === 200 && html.includes("<!DOCTYPE html>")) {
-      writeCache(pathname, html);
+      if (config.FLOWRIX_CACHE == "true" || config.public.FLOWRIX_CACHE == "true") {
+        writeCache(url, html, customerType);
+      }
     }
     return originalEnd.apply(this, arguments);
   };

package/dist/types.d.mts

@@ -1,3 +1,7 @@
-export { default } from './module.mjs'
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module.mjs'
 
-export { type ModuleOptions } from './module.mjs'
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { default } from './module.mjs'

package/package.json

@@ -1,13 +1,17 @@
 {
   "name": "flowrix",
-  "version": "1.0.1-beta.14",
-  "description": "lug-and-play Nuxt eCommerce cart powered by FLOWRiX. Subscription required.",
+  "version": "1.0.1-beta.141",
+  "description": "Plug-and-play Nuxt eCommerce cart powered by FLOWRiX. Subscription required.",
   "license": "MIT",
   "type": "module",
   "exports": {
     ".": {
       "types": "./dist/types.d.mts",
       "import": "./dist/module.mjs"
+    },
+    "./composables": {
+      "types": "./dist/runtime/composables/index.d.ts",
+      "import": "./dist/runtime/composables/index.js"
     }
   },
   "main": "./dist/module.mjs",
@@ -15,12 +19,14 @@
     "*": {
       ".": [
         "./dist/types.d.mts"
+      ],
+      "composables": [
+        "./dist/runtime/composables/index.d.ts"
       ]
     }
   },
   "files": [
-    "dist",
-    "runtime/stores"
+    "dist"
   ],
   "scripts": {
     "prepack": "nuxt-module-build build",
@@ -37,19 +43,24 @@
     "@nuxt/kit": "4.2.0",
     "@pinia/nuxt": "0.7.0",
     "@stripe/stripe-js": "8.2.0",
+    "@vueuse/nuxt": "14.0.0",
+    "defu": "^6.1.4",
+    "nuxt-swiper": "2.0.1",
+    "nuxt-toast": "1.4.0",
     "pinia": "2.3.1",
     "pinia-plugin-persistedstate": "3.2.3"
   },
   "devDependencies": {
     "@nuxt/devtools": "2.6.5",
     "@nuxt/eslint-config": "1.9.0",
-    "@nuxt/module-builder": "1.0.2",
+    "@nuxt/module-builder": "^1.0.2",
     "@nuxt/schema": "4.2.0",
     "@nuxt/test-utils": "3.19.2",
     "@types/node": "24.9.1",
     "changelogen": "0.6.2",
     "eslint": "9.38.0",
     "nuxt": "4.2.0",
+    "sass": "^1.94.2",
     "typescript": "5.9.3",
     "vitest": "3.2.4",
     "vue-tsc": "3.1.1"

package/dist/runtime/composables/Checkout/useBillingAddress.d.ts

@@ -1,19 +0,0 @@
-export default function (inputData: any): {
-    checkoutStore: any;
-    passwordShow: import("vue").Ref<string, string>;
-    password: import("vue").Ref<string, string>;
-    password_confirmationShow: import("vue").Ref<string, string>;
-    updateBillingAddress: (billingfield: any) => void;
-    UserAccount: import("vue").Ref<boolean, boolean>;
-    CheckUserAccount: (billingDetails: any, userEmail: string) => Promise<void>;
-    CheckingUserAccount: import("vue").Ref<boolean, boolean>;
-    passwordStrength: any;
-    passwordStrengthClass: any;
-    passwordStrengthValue: any;
-    passwordStrengthWidth: any;
-    passwordStrengthTextColor: any;
-    UpdateStripe: (inputData: any) => Promise<void>;
-    Countries: import("vue").Ref<never[], never[]>;
-    ChangeCountry: (billingfield: any) => Promise<void>;
-    States: import("vue").Ref<never[], never[]>;
-};