flowrix 1.0.0

package/LICENSE

@@ -0,0 +1,18 @@
+MIT License
+
+Copyright (c) 2025 Nimble Technology Pty Ltd (ACN 664 547 424) All rights reserved.
+
+This module (“Software”) is part of the FLOWRiX ecosystem and is provided for use only by licensed FLOWRiX subscribers under the FLOWRiX Terms of Use available at https://flowrix.com/terms-of-use.
+By installing, copying, or otherwise using this Software, you agree to be bound by the FLOWRiX Terms of Use.
+
+If you do not agree to those terms, you must not install or use this Software.
+
+Usage Conditions
+-A valid and active FLOWRiX eCommerce subscription is required.
+-You are granted a non-exclusive, non-transferable, revocable license to use this module solely for implementing eCommerce functionality in Nuxt projects connected to FLOWRiX.
+-You may not copy, modify, distribute, sublicense, reverse-engineer, or use this Software independently of FLOWRiX.
+-Use of this Software constitutes acceptance of all FLOWRiX Terms, including privacy, subscription, and third-party service clauses.
+
+Disclaimer
+This Software is provided “as is” without warranty of any kind, express or implied.
+Nimble Technology Pty Ltd is not liable for any damages or losses arising from use or inability to use this Software.

package/README.md

@@ -0,0 +1,84 @@
+<!--
+Get your module up and running quickly.
+
+Find and replace all on all files (CMD+SHIFT+F):
+- Name: My Module
+- Package name: flowrix
+- Description: My new Nuxt module
+-->
+
+# My Module
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![License][license-src]][license-href]
+[![Nuxt][nuxt-src]][nuxt-href]
+
+My new Nuxt module for doing amazing things.
+
+- [✨ &nbsp;Release Notes](/CHANGELOG.md)
+<!-- - [🏀 Online playground](https://stackblitz.com/github/your-org/flowrix?file=playground%2Fapp.vue) -->
+<!-- - [📖 &nbsp;Documentation](https://example.com) -->
+
+## Features
+
+<!-- Highlight some of the features your module provide here -->
+- ⛰ &nbsp;Foo
+- 🚠 &nbsp;Bar
+- 🌲 &nbsp;Baz
+
+## Quick Setup
+
+Install the module to your Nuxt application with one command:
+
+```bash
+npx nuxi module add flowrix
+```
+
+That's it! You can now use My Module in your Nuxt app ✨
+
+
+## Contribution
+
+<details>
+  <summary>Local development</summary>
+  
+  ```bash
+  # Install dependencies
+  npm install
+  
+  # Generate type stubs
+  npm run dev:prepare
+  
+  # Develop with the playground
+  npm run dev
+  
+  # Build the playground
+  npm run dev:build
+  
+  # Run ESLint
+  npm run lint
+  
+  # Run Vitest
+  npm run test
+  npm run test:watch
+  
+  # Release new version
+  npm run release
+  ```
+
+</details>
+
+
+<!-- Badges -->
+[npm-version-src]: https://img.shields.io/npm/v/flowrix/latest.svg?style=flat&colorA=020420&colorB=00DC82
+[npm-version-href]: https://npmjs.com/package/flowrix
+
+[npm-downloads-src]: https://img.shields.io/npm/dm/flowrix.svg?style=flat&colorA=020420&colorB=00DC82
+[npm-downloads-href]: https://npm.chart.dev/flowrix
+
+[license-src]: https://img.shields.io/npm/l/flowrix.svg?style=flat&colorA=020420&colorB=00DC82
+[license-href]: https://npmjs.com/package/flowrix
+
+[nuxt-src]: https://img.shields.io/badge/Nuxt-020420?logo=nuxt.js
+[nuxt-href]: https://nuxt.com

package/dist/module.d.mts

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

package/dist/module.json

@@ -0,0 +1,9 @@
+{
+  "name": "flowrix",
+  "configKey": "flowrix",
+  "version": "1.0.0",
+  "builder": {
+    "@nuxt/module-builder": "1.0.2",
+    "unbuild": "3.6.1"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,273 @@
+import { defineNuxtModule, createResolver, installModule, addPlugin, addImportsDir, addImports, addServerHandler } from '@nuxt/kit';
+
+const module = 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 resolver = createResolver(import.meta.url);
+    await installModule("@pinia/nuxt");
+    addPlugin({
+      src: resolver.resolve("./runtime/plugins/persistedstate.client"),
+      mode: "client"
+      // ensures only client side
+    });
+    addImportsDir(resolver.resolve("./runtime/composables"));
+    addImportsDir(resolver.resolve("./runtime/stores"));
+    addImports({
+      from: resolver.resolve("./runtime/middleware/flowrix"),
+      name: "flowrixApi"
+    });
+    addServerHandler({
+      route: "/api/albums",
+      handler: resolver.resolve("./runtime/server/api/albums")
+    });
+    addServerHandler({
+      route: "/api/banners",
+      handler: resolver.resolve("./runtime/server/api/banners")
+    });
+    addServerHandler({
+      route: "/api/location",
+      handler: resolver.resolve("./runtime/server/api/location")
+    });
+    addServerHandler({
+      route: "/api/subscribe",
+      handler: resolver.resolve("./runtime/server/api/subscribe")
+    });
+    addServerHandler({
+      route: "/api/auth/forgot",
+      handler: resolver.resolve("./runtime/server/api/auth/forgot")
+    });
+    addServerHandler({
+      route: "/api/auth/login",
+      handler: resolver.resolve("./runtime/server/api/auth/login")
+    });
+    addServerHandler({
+      route: "/api/auth/logout",
+      handler: resolver.resolve("./runtime/server/api/auth/logout")
+    });
+    addServerHandler({
+      route: "/api/auth/register",
+      handler: resolver.resolve("./runtime/server/api/auth/register")
+    });
+    addServerHandler({
+      route: "/api/auth/session",
+      handler: resolver.resolve("./runtime/server/api/auth/session.get")
+    });
+    addServerHandler({
+      route: "/api/auth/user/reset-password",
+      handler: resolver.resolve("./runtime/server/api/auth/user/reset-password")
+    });
+    addServerHandler({
+      route: "/api/auth/user/session",
+      handler: resolver.resolve("./runtime/server/api/auth/user/session")
+    });
+    addServerHandler({
+      route: "/api/auth/user/verify-token",
+      handler: resolver.resolve("./runtime/server/api/auth/user/verify-token")
+    });
+    addServerHandler({
+      route: "/api/blog/:slug",
+      handler: resolver.resolve("./runtime/server/api/blog/[slug]")
+    });
+    addServerHandler({
+      route: "/api/blog/blog",
+      handler: resolver.resolve("./runtime/server/api/blog/blog")
+    });
+    addServerHandler({
+      route: "/api/brand/:slug",
+      handler: resolver.resolve("./runtime/server/api/brand/[slug]")
+    });
+    addServerHandler({
+      route: "/api/cart/remove",
+      handler: resolver.resolve("./runtime/server/api/cart/remove")
+    });
+    addServerHandler({
+      route: "/api/cart/:slug/add",
+      handler: resolver.resolve("./runtime/server/api/cart/[slug]/add")
+    });
+    addServerHandler({
+      route: "/api/cart/:slug/update",
+      handler: resolver.resolve("./runtime/server/api/cart/[slug]/update")
+    });
+    addServerHandler({
+      route: "/api/cart/service/:slug/add",
+      handler: resolver.resolve("./runtime/server/api/cart/service/[slug]/add")
+    });
+    addServerHandler({
+      route: "/api/catalog/categories",
+      handler: resolver.resolve("./runtime/server/api/catalog/categories")
+    });
+    addServerHandler({
+      route: "/api/catalog/featured",
+      handler: resolver.resolve("./runtime/server/api/catalog/featured")
+    });
+    addServerHandler({
+      route: "/api/catalog/samples",
+      handler: resolver.resolve("./runtime/server/api/catalog/samples")
+    });
+    addServerHandler({
+      route: "/api/catalog/search",
+      handler: resolver.resolve("./runtime/server/api/catalog/search")
+    });
+    addServerHandler({
+      route: "/api/category/**",
+      handler: resolver.resolve("./runtime/server/api/category/[...slug]")
+    });
+    addServerHandler({
+      route: "/api/checkout/applyCoupon",
+      handler: resolver.resolve("./runtime/server/api/checkout/applyCoupon")
+    });
+    addServerHandler({
+      route: "/api/checkout/configs",
+      handler: resolver.resolve("./runtime/server/api/checkout/configs")
+    });
+    addServerHandler({
+      route: "/api/checkout/countries",
+      handler: resolver.resolve("./runtime/server/api/checkout/countries")
+    });
+    addServerHandler({
+      route: "/api/checkout/paymentmethod",
+      handler: resolver.resolve("./runtime/server/api/checkout/paymentmethod")
+    });
+    addServerHandler({
+      route: "/api/company/profile",
+      handler: resolver.resolve("./runtime/server/api/company/profile")
+    });
+    addServerHandler({
+      route: "/api/contact-center/webforms/create",
+      handler: resolver.resolve("./runtime/server/api/contact-center/webforms/create")
+    });
+    addServerHandler({
+      route: "/api/contact-center/webforms/:id/details",
+      handler: resolver.resolve("./runtime/server/api/contact-center/webforms/[id]/details")
+    });
+    addServerHandler({
+      route: "/api/customer/change-password",
+      handler: resolver.resolve("./runtime/server/api/customer/change-password")
+    });
+    addServerHandler({
+      route: "/api/customer/checkout",
+      handler: resolver.resolve("./runtime/server/api/customer/checkout")
+    });
+    addServerHandler({
+      route: "/api/customer/orders",
+      handler: resolver.resolve("./runtime/server/api/customer/orders")
+    });
+    addServerHandler({
+      route: "/api/customer/quotations",
+      handler: resolver.resolve("./runtime/server/api/customer/quotations")
+    });
+    addServerHandler({
+      route: "/api/customer/search",
+      handler: resolver.resolve("./runtime/server/api/customer/search")
+    });
+    addServerHandler({
+      route: "/api/customer/tax-invoice",
+      handler: resolver.resolve("./runtime/server/api/customer/tax-invoice")
+    });
+    addServerHandler({
+      route: "/api/customer/address/add",
+      handler: resolver.resolve("./runtime/server/api/customer/address/add")
+    });
+    addServerHandler({
+      route: "/api/customer/address/delete",
+      handler: resolver.resolve("./runtime/server/api/customer/address/delete")
+    });
+    addServerHandler({
+      route: "/api/customer/address/setshipping",
+      handler: resolver.resolve("./runtime/server/api/customer/address/setshipping")
+    });
+    addServerHandler({
+      route: "/api/customer/address/update",
+      handler: resolver.resolve("./runtime/server/api/customer/address/update")
+    });
+    addServerHandler({
+      route: "/api/customer/cards/delete",
+      handler: resolver.resolve("./runtime/server/api/customer/cards/delete")
+    });
+    addServerHandler({
+      route: "/api/customer/cards/get",
+      handler: resolver.resolve("./runtime/server/api/customer/cards/get")
+    });
+    addServerHandler({
+      route: "/api/customer/profile/update",
+      handler: resolver.resolve("./runtime/server/api/customer/profile/update")
+    });
+    addServerHandler({
+      route: "/api/customer/wishlist/add",
+      handler: resolver.resolve("./runtime/server/api/customer/wishlist/add")
+    });
+    addServerHandler({
+      route: "/api/customer/wishlist/createWishList",
+      handler: resolver.resolve("./runtime/server/api/customer/wishlist/createWishList")
+    });
+    addServerHandler({
+      route: "/api/customer/wishlist/deleteFromWishList",
+      handler: resolver.resolve("./runtime/server/api/customer/wishlist/deleteFromWishList")
+    });
+    addServerHandler({
+      route: "/api/customer/wishlist/deleteWishList",
+      handler: resolver.resolve("./runtime/server/api/customer/wishlist/deleteWishList")
+    });
+    addServerHandler({
+      route: "/api/customer/wishlist/get",
+      handler: resolver.resolve("./runtime/server/api/customer/wishlist/get")
+    });
+    addServerHandler({
+      route: "/api/customer/wishlist/getWishListItems",
+      handler: resolver.resolve("./runtime/server/api/customer/wishlist/getWishListItems")
+    });
+    addServerHandler({
+      route: "/api/customer/wishlist/updateWishList",
+      handler: resolver.resolve("./runtime/server/api/customer/wishlist/updateWishList")
+    });
+    addServerHandler({
+      route: "/api/nav/:id/links",
+      handler: resolver.resolve("./runtime/server/api/nav/[id]/links")
+    });
+    addServerHandler({
+      route: "/api/page/:slug",
+      handler: resolver.resolve("./runtime/server/api/page/[slug]")
+    });
+    addServerHandler({
+      route: "/api/product/**",
+      handler: resolver.resolve("./runtime/server/api/product/[...slug]")
+    });
+    addServerHandler({
+      route: "/api/service/:slug",
+      handler: resolver.resolve("./runtime/server/api/service/[slug]")
+    });
+    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]")
+    });
+    addPlugin(resolver.resolve("./runtime/plugin"));
+  }
+});
+
+export { module as default };

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

@@ -0,0 +1,111 @@
+interface BlogPost {
+    id: number;
+    category: string;
+    title: string;
+    name: string;
+    image: string;
+    url: string;
+}
+interface BlogCategory {
+    name: string;
+    url: string;
+}
+interface BlogData {
+    data: {
+        posts: {
+            data: BlogPost[];
+        };
+        categories: BlogCategory[];
+    };
+}
+export declare const useBlogIndex: () => {
+    activeCategory: import("vue").Ref<string, string>;
+    loading: import("vue").Ref<boolean, boolean>;
+    shopQuery: import("vue").Ref<{
+        limit: number;
+        page: number;
+        category: string;
+        search: string;
+    }, {
+        limit: number;
+        page: number;
+        category: string;
+        search: string;
+    } | {
+        limit: number;
+        page: number;
+        category: string;
+        search: string;
+    }>;
+    PostItems: import("vue").Ref<{
+        id: number;
+        category: string;
+        title: string;
+        name: string;
+        image: string;
+        url: string;
+    }[], BlogPost[] | {
+        id: number;
+        category: string;
+        title: string;
+        name: string;
+        image: string;
+        url: string;
+    }[]>;
+    PostsData: import("vue").Ref<{
+        data: {
+            posts: {
+                data: {
+                    id: number;
+                    category: string;
+                    title: string;
+                    name: string;
+                    image: string;
+                    url: string;
+                }[];
+            };
+            categories: {
+                name: string;
+                url: string;
+            }[];
+        };
+    } | null, BlogData | {
+        data: {
+            posts: {
+                data: {
+                    id: number;
+                    category: string;
+                    title: string;
+                    name: string;
+                    image: string;
+                    url: string;
+                }[];
+            };
+            categories: {
+                name: string;
+                url: string;
+            }[];
+        };
+    } | null>;
+    total: import("vue").Ref<number, number>;
+    displayPosts: import("vue").ComputedRef<{
+        id: number;
+        category: string;
+        title: string;
+        name: string;
+        image: string;
+        url: string;
+    }[]>;
+    progressPercentage: import("vue").ComputedRef<number>;
+    canLoadMore: import("vue").ComputedRef<boolean>;
+    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>;
+    }>;
+};
+export {};

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

@@ -0,0 +1,86 @@
+import { ref, computed, watch, onMounted } from "vue";
+import { useFetch } from "#imports";
+export const useBlogIndex = () => {
+  const activeCategory = ref("All");
+  const loading = ref(false);
+  const limit = 4;
+  const currentIndex = ref(0);
+  const total = ref(0);
+  const shopQuery = ref({
+    limit: 6,
+    page: 1,
+    category: "",
+    search: ""
+  });
+  const PostItems = ref([]);
+  const PostsData = ref(null);
+  const queryString = (querydata) => {
+    const params = new URLSearchParams();
+    params.append("limit", querydata.limit.toString());
+    params.append("page", querydata.page.toString());
+    params.append("category", querydata.category !== "All" ? querydata.category : "");
+    params.append("search", querydata.search);
+    return params.toString();
+  };
+  const loadMore = async () => {
+    if (loading.value || currentIndex.value >= total.value) return;
+    loading.value = true;
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    shopQuery.value.page += 1;
+    await fetchBlogData();
+    loading.value = false;
+  };
+  const clearSearch = () => {
+    PostItems.value = [];
+    shopQuery.value.page = 1;
+    shopQuery.value.search = "";
+    currentIndex.value = 0;
+  };
+  const fetchBlogData = async () => {
+    try {
+      const { data, pending } = await useFetch(() => `/api/blog/blog?${queryString(shopQuery.value)}`, {
+        method: "POST",
+        watch: [() => shopQuery.value.category],
+        server: false
+      });
+      watch(data, (newData) => {
+        if (newData) {
+          PostsData.value = newData;
+          PostItems.value.push(...newData.data?.posts?.data || []);
+          total.value = newData.data?.posts?.data.length || 0;
+        }
+      });
+      onMounted(() => {
+        if (data.value) {
+          PostsData.value = data.value;
+          PostItems.value.push(...data.value.data?.posts?.data || []);
+          total.value = data.value.data?.posts?.data.length || 0;
+        }
+      });
+      return { data, pending };
+    } catch (error) {
+      console.error("Failed to fetch blog data:", error);
+      return { data: ref(null), pending: ref(false) };
+    }
+  };
+  const displayPosts = computed(() => PostItems.value);
+  const progressPercentage = computed(() => PostItems.value.length / total.value * 100);
+  const canLoadMore = computed(() => !loading.value && PostItems.value.length < total.value);
+  return {
+    // State
+    activeCategory,
+    loading,
+    shopQuery,
+    PostItems,
+    PostsData,
+    total,
+    // Computed
+    displayPosts,
+    progressPercentage,
+    canLoadMore,
+    // Methods
+    loadMore,
+    clearSearch,
+    fetchBlogData
+  };
+};

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

@@ -0,0 +1,13 @@
+interface BlogPost {
+    name: string;
+    short_description: string;
+    url: string;
+    image: string;
+}
+interface BlogMainProps {
+    post: BlogPost;
+}
+export declare const useBlogMain: (props: BlogMainProps) => {
+    post: import("vue").ComputedRef<BlogPost>;
+};
+export {};

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

@@ -0,0 +1,7 @@
+import { computed } from "vue";
+export const useBlogMain = (props) => {
+  const post = computed(() => props.post);
+  return {
+    post
+  };
+};

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

@@ -0,0 +1,7 @@
+export declare const useBlogSidebar: () => {
+    categories: import("vue").Ref<string[], string[]>;
+    email: import("vue").Ref<string, string>;
+    isSubscribing: import("vue").Ref<boolean, boolean>;
+    subscribeToNewsletter: () => Promise<void>;
+    selectCategory: (category: string) => void;
+};

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

@@ -0,0 +1,37 @@
+import { ref } from "vue";
+export const useBlogSidebar = () => {
+  const categories = ref([
+    "Automation",
+    "Bedroom",
+    "Blinds",
+    "Curtains",
+    "Shutters",
+    "Bathroom",
+    "Motorisation",
+    "Office"
+  ]);
+  const email = ref("");
+  const isSubscribing = ref(false);
+  const subscribeToNewsletter = async () => {
+    if (!email.value) return;
+    isSubscribing.value = true;
+    try {
+      email.value = "";
+    } catch (error) {
+      console.error("Newsletter subscription failed:", error);
+    } finally {
+      isSubscribing.value = false;
+    }
+  };
+  const selectCategory = (category) => {
+  };
+  return {
+    // State
+    categories,
+    email,
+    isSubscribing,
+    // Methods
+    subscribeToNewsletter,
+    selectCategory
+  };
+};