@scayle/storefront-product-listing 0.6.0 → 1.0.0

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@scayle/storefront-product-listing",
   "configKey": "product-listing",
-  "version": "0.0.1",
+  "version": "1.0.0",
   "compatibility": {
     "bridge": false,
     "nuxt": ">=3.13"

package/dist/module.mjs

@@ -4,7 +4,7 @@ const module = defineNuxtModule({
   meta: {
     name: "@scayle/storefront-product-listing",
     configKey: "product-listing",
-    version: "0.0.1",
+    version: "1.0.0",
     compatibility: {
       bridge: false,
       nuxt: ">=3.13"

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

@@ -7,34 +7,24 @@ export interface AppliedFiltersOptions {
     filtersPrefix: string;
 }
 export interface UseAppliedFiltersReturn {
+    /** A computed property returning a `ProductSearchQuery` object based on the route's query parameters. */
     appliedFilter: ComputedRef<ProductSearchQuery>;
+    /** A computed property that returns the total count of applied filters. Counts minPrice/maxPrice as one and counts each attribute filter separately. */
     appliedFiltersCount: ComputedRef<number>;
+    /** A computed property that returns a record mapping attribute keys to their boolean values for boolean filters. */
     appliedBooleanValues: ComputedRef<AppliedBooleanValues>;
+    /** A computed property that returns a record mapping attribute keys to arrays of numbers representing selected values for each attribute. */
     appliedAttributeValues: ComputedRef<AppliedAttributeValues>;
+    /** A computed property that returns `true` if any filters are currently applied, otherwise `false`. */
     areFiltersApplied: ComputedRef<boolean>;
 }
 /**
  * Composable to manage applied filters based on route query parameters.
  *
- * @param {RouteLocationNormalizedLoadedGeneric} [route] - Route object to handle the queries.
- * @param {AppliedFiltersOptions} options - Configuration options for applied filters.
- * @param {string} options.filtersPrefix - The prefix used to identify filter-related query parameters.
+ * @param route Route object to handle the queries.
+ * @param options Configuration options for applied filters.
+ * @param options.filtersPrefix The prefix used to identify filter-related query parameters.
  *
- * @returns {UseAppliedFiltersReturn} - An object containing reactive data and computed properties for managing applied filters:
- *
- * - `appliedFilter` {ComputedRef<ProductSearchQuery>}: A computed property returning a `ProductSearchQuery` object based on the route's query parameters.
- *   - `attributes`: An array of attribute filters, where each filter has:
- *       - `type`: A string, either 'boolean' or 'attributes'.
- *       - `key`: The name of the attribute.
- *       - `value`: A boolean for boolean filters.
- *       - `values`: An array of numbers for attribute filters.
- *   - `minPrice`: (Optional) The minimum price filter as a number.
- *   - `maxPrice`: (Optional) The maximum price filter as a number.
- *   - `term`: (Optional) A search term filter as a string.
- *
- * - `appliedFiltersCount` {ComputedRef<number>}: A computed property that returns the total count of applied filters. Counts minPrice/maxPrice as one and counts each attribute filter separately.
- * - `appliedAttributeValues` {ComputedRef<AppliedAttributeValues>}: A computed property that returns a record mapping attribute keys to arrays of numbers representing selected values for each attribute.
- * - `appliedBooleanValues` {ComputedRef<appliedBooleanValues>}: A computed property that returns a record mapping attribute keys to their boolean values for boolean filters.
- * - `areFiltersApplied` {ComputedRef<boolean>}: A computed property that returns `true` if any filters are currently applied, otherwise `false`.
+ * @returns An object containing reactive data and computed properties for managing applied filters:
  */
 export declare function useAppliedFilters(route: RouteLocationNormalizedLoadedGeneric, { filtersPrefix }?: AppliedFiltersOptions): UseAppliedFiltersReturn;

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

@@ -11,23 +11,19 @@ export type FiltersForListingOptions = Partial<{
     fetchingKey: string;
 }>;
 export type UseFiltersForListingReturn = Pick<Awaited<ReturnType<typeof useFilters>>, 'error' | 'status' | 'refresh'> & {
+    /** Returns computed available filters. */
     availableFilters: ComputedRef<FilterItemWithValues[]>;
+    /** Returns the count of the products which the applied filter returns. */
     filteredProductCount: ComputedRef<number>;
 };
 /**
  * Composable to manage filters based on current category ID and route query parameters.
  *
- * @param {FiltersForListingOptions} options - Configuration options for fetching products.
- * @param {Partial<FetchFiltersParams>} options.params - Parameters to control product fetch behavior, excluding `category`.
- * @param {Partial<{ lazy: boolean; immediate: boolean }>} options.fetchingOptions - Options for fetch timing, such as lazy loading or immediate fetching.
- * @param {string} [options.fetchingKey] - Optional unique key to control the fetching cache.
+ * @param options Configuration options for fetching products.
+ * @param options.params Parameters to control product fetch behavior, excluding `category`.
+ * @param options.fetchingOptions Options for fetch timing, such as lazy loading or immediate fetching.
+ * @param options.fetchingKey Optional unique key to control the fetching cache.
  *
  * @returns {UseFiltersForListingReturn} - An object containing reactive data, computed properties and async RPC call for managing filters:
- *   - `fetch`: call for fetching the filters.
- *   - `error`: returns "useFilters" error.
- *   - `status`: returns "useFilters" status.
- *   - `fetching`: returns "useFilters" fetching flag.
- *   - `availableFilters` {ComputedRef<FilterItemWithValues[]>}: returns computed available filters.
- *   - `filteredProductCount` {ComputedRef<number>}: returns the count of the products which the applied filter returns.
  */
 export declare function useFiltersForListing({ params, fetchingKey, fetchingOptions, }?: FiltersForListingOptions): UseFiltersForListingReturn & Promise<UseFiltersForListingReturn>;

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

@@ -9,8 +9,11 @@ type SortLink = SelectedSort & {
     to: RouteLocationRaw;
 };
 export interface UseProductListSortReturn {
+    /** The currently selected sorting option. */
     selectedSort: ComputedRef<SelectedSort | undefined>;
+    /** Links with updated query parameters for each sorting option. */
     sortLinks: ComputedRef<SortLink[]>;
+    /** Indicating if the default sort is selected. */
     isDefaultSortSelected: ComputedRef<boolean>;
 }
 export interface ProductListSortOptions {
@@ -20,16 +23,12 @@ export interface ProductListSortOptions {
 /**
  * Custom composable to handle product list sorting.
  *
- * @param {RouteLocationNormalizedLoadedGeneric} [route] - Route object to handle the queries and path.
- * @param {ProductListSortOptions} [options] - Options for configuring the sorting behavior.
- * @param {SelectedSort[]} [options.sortingOptions] - Array of available sorting options.
- * @param {string} [options.defaultSortingKey] - Default sorting key to be applied if no specific sort is selected.
+ * @param route Route object to handle the queries and path.
+ * @param options Options for configuring the sorting behavior.
+ * @param options.sortingOptions Array of available sorting options.
+ * @param options.defaultSortingKey Default sorting key to be applied if no specific sort is selected.
  *
- * @returns - computed properties and methods related to sorting:
- *
- * - {ComputedRef<SelectedSort | undefined>} selectedSort - The currently selected sorting option.
- * - {ComputedRef<SortLink[]>} sortLinks - Links with updated query parameters for each sorting option.
- * - {ComputedRef<boolean>} isDefaultSortSelected - Boolean indicating if the default sort is selected.
+ * @returns Computed properties and methods related to sorting
  */
 export declare function useProductListSort(route: RouteLocationNormalizedLoadedGeneric, { sortingOptions, defaultSortingKey }?: ProductListSortOptions): UseProductListSortReturn;
 export {};

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

@@ -5,24 +5,25 @@ import type { RouteLocationNormalizedLoadedGeneric } from 'vue-router';
 type CanonicalLink = Record<'rel' | 'key' | 'href', string>;
 type UrlParams = Record<'baseUrl' | 'fullPath', string>;
 export interface UseProductListingSeoDataReturn {
+    /** A computed string that is constructed from breadcrumb values. */
     title: ComputedRef<string>;
+    /** A computed robots. Value can be `index,follow` or `noindex,follow`. */
     robots: ComputedRef<string>;
+    /** A computed canonical link. */
     canonicalLink: ComputedRef<CanonicalLink[]>;
+    /** A computed breadcrumb schema. */
     categoryBreadcrumbSchema: ComputedRef<WithContext<BreadcrumbList> | []>;
 }
 /**
  * Composable for handling product listing SEO data.
  *
- * @param {MaybeRefOrGetter<BreadcrumbItem[]>} breadcrumbs - Breadcrumb items.
- * @param {RouteLocationNormalizedLoadedGeneric} [route] - route object to handle queries.
- * @param {UrlParams} URL params - URL data for constructing the canonical link.
+ * @param breadcrumbs Breadcrumb items.
+ * @param route The route object to handle queries.
+ * @param params - URL data for constructing the canonical link.
+ * @param params.baseUrl The base URL of the application.
+ * @param params.fullPath - The full path of the current route.
  *
- * @returns {UseProductListingSeoDataReturn} An object containing reactive data and computed properties for managing SEO data.
- *
- * @property {ComputedRef<string>} title - A computed string that is constructed from breadcrumb values.
- * @property {ComputedRef<string>} robots - A computed robots. Value can be "index,follow" or "noindex,follow".
- * @property {ComputedRef<CanonicalLink[]>} canonicalLink - A computed canonical link.
- * @property {ComputedRef<WithContext<BreadcrumbList> | []>} categoryBreadcrumbSchema - A computed breadcrumb schema.
+ * @returns An object containing reactive data and computed properties for managing SEO data.
  */
 export declare function useProductListingSeoData(breadcrumbs: MaybeRefOrGetter<BreadcrumbItem[]>, route: RouteLocationNormalizedLoadedGeneric, { baseUrl, fullPath }: UrlParams): UseProductListingSeoDataReturn;
 export {};

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

@@ -3,8 +3,11 @@ import { type MaybeRefOrGetter, type ComputedRef } from 'vue';
 import { useProducts } from '@scayle/storefront-nuxt/composables';
 import type { Pagination } from '@scayle/storefront-api';
 export type UseProductsForListingReturn = Pick<Awaited<ReturnType<typeof useProducts>>, 'error' | 'status'> & {
+    /** A computed array of products in the specified category. */
     products: ComputedRef<Product[]>;
+    /** A computed object containing pagination details for the product list. */
     pagination: ComputedRef<Pagination | undefined>;
+    /** A computed offset for the current page based on the pagination data. */
     totalProductsCount: ComputedRef<number>;
     paginationOffset: ComputedRef<number>;
 };
@@ -19,17 +22,11 @@ export interface ProductsForListingOptions {
 /**
  * Composable to fetch and manage products by category with configurable options.
  *
- * @param {ProductsForListingOptions} options - Configuration options for fetching products.
- * @param {Partial<FetchProductsByCategoryParams>} options.params - Parameters to control product fetch behavior, excluding `category`.
- * @param {Partial<{ lazy: boolean; immediate: boolean }>} options.fetchingOptions - Options for fetch timing, such as lazy loading or immediate fetching.
- * @param {string} [options.fetchingKey] - Optional unique key to control the fetching cache.
+ * @param options Configuration options for fetching products.
+ * @param options.params Parameters to control product fetch behavior, excluding `category`.
+ * @param options.fetchingOptions Options for fetch timing, such as lazy loading or immediate fetching.
+ * @param options.fetchingKey Optional unique key to control the fetching cache.
  *
- * @returns {UseProductsByCategoryReturn} - An object containing reactive data and computed properties for managing products by category.
- * @property {ComputedRef<Product[]>} products - A computed array of products in the specified category.
- * @property {ComputedRef<Pagination>} pagination - A computed object containing pagination details for the product list.
- * @property {ComputedRef<number>} totalProductsCount - A computed total count of products in the category.
- * @property {ComputedRef<number>} paginationOffset - A computed offset for the current page based on the pagination data.
- * @property {Ref<boolean>} fetching - A reactive boolean indicating if products are currently being fetched.
- * @property {Ref<Error | null>} error - A reactive error object, null if no error occurred.
+ * @returns An object containing reactive data and computed properties for managing products by category.
  */
 export declare function useProductsForListing({ params, fetchingKey, fetchingOptions, }?: Partial<ProductsForListingOptions>): UseProductsForListingReturn & Promise<UseProductsForListingReturn>;

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

@@ -1,14 +1,61 @@
 import type { LocationQuery, RouteLocationNormalizedLoadedGeneric } from 'vue-router';
 import type { ProductSearchQuery } from '@scayle/storefront-api';
 import type { RangeTuple } from '~/src';
+/**
+ * Parses filter data from a Vue Router route object.
+ *
+ * @param route The Vue Router route object.
+ * @param filtersPrefix The prefix used for filter query parameters.
+ *
+ * @returns An object representing the parsed product search query.
+ */
 export declare const parseFilterDataFromRoute: (route: RouteLocationNormalizedLoadedGeneric, filtersPrefix: string) => ProductSearchQuery;
+/**
+ * Creates a new attribute filter query object.
+ *
+ * @param route The Vue Router route object.
+ * @param appliedFilter The currently applied filter.
+ * @param param An object containing the slug and ID of the attribute.
+ * @param param.slug The slug of the attribute.
+ * @param param.id The ID of the attribute.
+ *
+ * @returns A new query object with the updated attribute filter.
+ */
 export declare const createNewAttributeQuery: (route: RouteLocationNormalizedLoadedGeneric, appliedFilter: ProductSearchQuery, { slug, id }: {
     slug: string;
     id: number;
 }) => LocationQuery;
+/**
+ * Creates a new price filter query object.
+ *
+ * @param {RouteLocationNormalizedLoadedGeneric} route - The Vue Router route object.
+ * @param {ProductSearchQuery} appliedFilter - The currently applied filter.
+ * @param {RangeTuple} prices - The new price range.
+ *
+ * @returns {LocationQuery} A new query object with the updated price filter.
+ */
 export declare const createNewPriceQuery: (route: RouteLocationNormalizedLoadedGeneric, appliedFilter: ProductSearchQuery, prices: RangeTuple) => LocationQuery;
+/**
+ * Creates a new boolean attribute filter query object.
+ *
+ * @param route - The Vue Router route object.
+ * @param appliedFilter - The currently applied filter.
+ * @param param - An object containing the slug and value of the boolean attribute.
+ * @param param.slug - The slug of the attribute.
+ * @param param.value - The value of the attribute.
+ *
+ * @returns A new query object with the updated boolean attribute filter.
+ */
 export declare const createNewBoolAttributeQuery: (route: RouteLocationNormalizedLoadedGeneric, appliedFilter: ProductSearchQuery, { slug, value }: {
     slug: string;
     value: boolean;
 }) => LocationQuery;
+/**
+ * Returns a new query object with the filter for the specified key cleared.
+ *
+ * @param route - The Vue Router route object.
+ * @param key - The key of the filter to clear.
+ *
+ * @returns A new query object with the filter cleared.
+ */
 export declare const getClearedFilterQueryByKey: (route: RouteLocationNormalizedLoadedGeneric, key: string) => LocationQuery;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scayle/storefront-product-listing",
-  "version": "0.6.0",
+  "version": "1.0.0",
   "description": "Collection of essential composables and utilities to work with product listing",
   "author": "SCAYLE Commerce Engine",
   "license": "MIT",
@@ -45,7 +45,7 @@
   },
   "peerDependencies": {
     "@nuxt/kit": "^3.13.0",
-    "@scayle/storefront-nuxt": "^7.93.0 || ^8.0.0",
+    "@scayle/storefront-nuxt": "^8.0.0",
     "@vue/test-utils": "2.4.6",
     "@vueuse/core": "12.0.0",
     "fishery": "2.2.2",
@@ -57,8 +57,8 @@
     "@nuxt/schema": "3.13.2",
     "@nuxt/test-utils": "3.15.1",
     "@scayle/eslint-config-storefront": "4.3.2",
-    "@scayle/storefront-nuxt": "8.1.1",
-    "@types/node": "22.10.1",
+    "@scayle/storefront-nuxt": "8.1.3",
+    "@types/node": "22.10.2",
     "@vue/test-utils": "2.4.6",
     "@vueuse/core": "12.0.0",
     "dprint": "0.47.6",