@scayle/storefront-nuxt 7.74.0 → 7.75.1

package/dist/runtime/composables/storefront/useFacet.mjs

@@ -4,10 +4,12 @@ import { useCategories } from "../storefront/useCategories.mjs";
 import { useFilters } from "../storefront/useFilters.mjs";
 import { useProducts } from "../storefront/useProducts.mjs";
 import { useProductsCount } from "../storefront/useProductsCount.mjs";
-export async function useFacet({
-  key = "useFacet",
+import { extendPromise } from "../../utils/promise.mjs";
+export function useFacet({
+  key: optionsKey,
   params = { initialPath: "/" }
-} = {}) {
+} = {}, _key) {
+  const key = optionsKey ?? _key ?? "useFacet";
   const currentPath = useState(
     `${key}-path`,
     () => params.initialPath ?? "/"
@@ -31,86 +33,83 @@ export async function useFacet({
   const productCountWhere = useState(
     `${key}-productCountWhereCondition`
   );
-  const [
-    {
-      data: categoryData,
-      fetch: refreshCategories,
-      fetching: categoriesFetching,
-      error: categoriesError,
-      status: categoriesStatus
-    },
-    {
-      data: productData,
-      fetch: _refreshProducts,
-      fetching: productsFetching,
-      error: productError,
-      status: productStatus
-    },
-    {
-      data: productCountData,
-      fetch: _refreshProductCount,
-      fetching: productCountFetching,
-      error: productCountError,
-      status: productCountStatus
-    },
-    {
-      data: filterData,
-      fetch: refreshFilters,
-      fetching: filtersFetching,
-      error: filterError,
-      status: filterStatus
-    }
-  ] = await Promise.all([
-    useCategories({
-      params: () => ({
-        path: currentPath.value,
-        includeHidden: params.with?.product?.categories?.includeHidden || void 0
-      }),
-      options: { autoFetch: false },
-      key: `${key}-categories`
+  const categoriesPromise = useCategories({
+    params: () => ({
+      path: currentPath.value,
+      includeHidden: params.with?.product?.categories?.includeHidden || void 0
     }),
-    useProducts({
-      params: () => ({
-        page: currentPage.value,
-        perPage: currentPerPage.value,
-        with: params.with?.product,
-        category: currentPath.value,
-        includeSoldOut: params.includeSoldOut,
-        includeSellableForFree: params.includeSellableForFree,
-        where: currentWhereCondition.value,
-        sort: currentSorting.value,
-        pricePromotionKey: currentPricePromotionKey.value,
-        cache: currentCacheParams.value,
-        orFiltersOperator: currentOrFiltersOperator.value
-      }),
-      options: { autoFetch: false },
-      key: `${key}-products`
+    options: { immediate: false },
+    key: `${key}-categories`
+  });
+  const productsPromise = useProducts({
+    params: () => ({
+      page: currentPage.value,
+      perPage: currentPerPage.value,
+      with: params.with?.product,
+      category: currentPath.value,
+      includeSoldOut: params.includeSoldOut,
+      includeSellableForFree: params.includeSellableForFree,
+      where: currentWhereCondition.value,
+      sort: currentSorting.value,
+      pricePromotionKey: currentPricePromotionKey.value,
+      cache: currentCacheParams.value,
+      orFiltersOperator: currentOrFiltersOperator.value
     }),
-    useProductsCount({
-      params: () => ({
-        category: currentPath.value,
-        includedFilters: params.includedFilters,
-        includeSoldOut: params.includeSoldOut,
-        includeSellableForFree: params.includeSellableForFree,
-        where: productCountWhere.value,
-        orFiltersOperator: currentOrFiltersOperator.value
-      }),
-      options: { autoFetch: false },
-      key: `${key}-productCount`
+    options: { immediate: false },
+    key: `${key}-products`
+  });
+  const productsCountPromise = useProductsCount({
+    params: () => ({
+      category: currentPath.value,
+      includedFilters: params.includedFilters,
+      includeSoldOut: params.includeSoldOut,
+      includeSellableForFree: params.includeSellableForFree,
+      where: productCountWhere.value,
+      orFiltersOperator: currentOrFiltersOperator.value
     }),
-    useFilters({
-      params: () => ({
-        category: currentPath.value,
-        includedFilters: params.includedFilters,
-        includeSoldOut: params.includeSoldOut,
-        includeSellableForFree: params.includeSellableForFree,
-        where: currentWhereCondition.value,
-        orFiltersOperator: currentOrFiltersOperator.value
-      }),
-      options: { autoFetch: false },
-      key: `${key}-filters`
-    })
-  ]);
+    options: { immediate: false },
+    key: `${key}-productCount`
+  });
+  const filtersPromise = useFilters({
+    params: () => ({
+      category: currentPath.value,
+      includedFilters: params.includedFilters,
+      includeSoldOut: params.includeSoldOut,
+      includeSellableForFree: params.includeSellableForFree,
+      where: currentWhereCondition.value,
+      orFiltersOperator: currentOrFiltersOperator.value
+    }),
+    options: { immediate: false },
+    key: `${key}-filters`
+  });
+  const {
+    data: categoryData,
+    fetch: refreshCategories,
+    fetching: categoriesFetching,
+    error: categoriesError,
+    status: categoriesStatus
+  } = categoriesPromise;
+  const {
+    data: productData,
+    fetch: _refreshProducts,
+    fetching: productsFetching,
+    error: productError,
+    status: productStatus
+  } = productsPromise;
+  const {
+    data: productCountData,
+    fetch: _refreshProductCount,
+    fetching: productCountFetching,
+    error: productCountError,
+    status: productCountStatus
+  } = productsCountPromise;
+  const {
+    data: filterData,
+    fetch: refreshFilters,
+    fetching: filtersFetching,
+    error: filterError,
+    status: filterStatus
+  } = filtersPromise;
   const categories = computed(() => categoryData.value?.categories);
   const selectedCategory = computed(() => categoryData.value?.activeNode);
   const pagination = computed(() => productData.value?.pagination);
@@ -170,34 +169,42 @@ export async function useFacet({
     currentPage.value = pageToFetch;
     await _refreshProducts();
   };
-  return {
-    // filter data
-    filters,
-    filtersFetching,
-    unfilteredCount,
-    filterStatus,
-    filterError,
-    // filter preview
-    productCountData,
-    refreshProductCount,
-    productCountFetching,
-    productCountError,
-    productCountStatus,
-    // product data
-    products,
-    pagination,
-    productsFetching,
-    filterProducts,
-    productError,
-    productStatus,
-    // category data
-    categories,
-    selectedCategory,
-    categoriesFetching,
-    categoriesError,
-    categoriesStatus,
-    // other
-    fetchProducts,
-    fetchPage
-  };
+  return extendPromise(
+    Promise.all([
+      categoriesPromise,
+      productsPromise,
+      productsCountPromise,
+      filtersPromise
+    ]).then(() => ({})),
+    {
+      // filter data
+      filters,
+      filtersFetching,
+      unfilteredCount,
+      filterStatus,
+      filterError,
+      // filter preview
+      productCountData,
+      refreshProductCount,
+      productCountFetching,
+      productCountError,
+      productCountStatus,
+      // product data
+      products,
+      pagination,
+      productsFetching,
+      filterProducts,
+      productError,
+      productStatus,
+      // category data
+      categories,
+      selectedCategory,
+      categoriesFetching,
+      categoriesError,
+      categoriesStatus,
+      // other
+      fetchProducts,
+      fetchPage
+    }
+  );
 }

package/dist/runtime/composables/storefront/useFilters.d.ts

@@ -1,19 +1,11 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { RpcOptions } from '../core/useRpc';
+import type { UseRpcOptions, UseRpcReturn } from '../core/useRpc';
 import type { MaybeRefOrGetter } from '#imports';
 type Options = Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getFilters'>>;
-    options: RpcOptions;
+    options: UseRpcOptions<'getFilters'>;
+    /** @deprecated use the second argument of the composable to define the key */
     key: string;
 }>;
-export declare function useFilters({ params, options, key, }?: Options): Promise<{
-    data: import("vue").Ref<{
-        filters: import("@scayle/storefront-api").FiltersEndpointResponseData;
-        unfilteredCount: number;
-    } | undefined>;
-    fetching: import("vue").Ref<boolean>;
-    fetch: () => Promise<void>;
-    error: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | undefined>;
-    status: import("vue").Ref<import("../core/useRpc").Status>;
-}>;
+export declare function useFilters({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'getFilters'>;
 export {};

package/dist/runtime/composables/storefront/useFilters.mjs

@@ -1,20 +1,13 @@
 import { useRpc } from "../core/useRpc.mjs";
-export async function useFilters({
+export function useFilters({
   params,
   options,
-  key = "useFilters"
-} = {}) {
-  const { data, fetching, fetch, error, status } = await useRpc(
+  key: _key
+} = {}, key) {
+  return useRpc(
     "getFilters",
-    key,
+    _key ?? key ?? "useFilters",
     params,
     options
   );
-  return {
-    data,
-    fetching,
-    fetch,
-    error,
-    status
-  };
 }

package/dist/runtime/composables/storefront/useNavigationTree.d.ts

@@ -1,16 +1,11 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { RpcOptions } from '../core/useRpc';
+import type { UseRpcOptions, UseRpcReturn } from '../core/useRpc';
 import type { MaybeRefOrGetter } from '#imports';
 type Options = Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'fetchNavigationTreeById'>>;
-    options: RpcOptions;
+    options: UseRpcOptions<'fetchNavigationTreeById'>;
+    /** @deprecated use the second argument of the composable to define the key */
     key: string;
 }>;
-export declare function useNavigationTree({ params, options, key, }?: Options): Promise<{
-    data: import("vue").Ref<import("@scayle/storefront-api").NavigationTree | undefined>;
-    fetching: import("vue").Ref<boolean>;
-    fetch: () => Promise<void>;
-    error: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | undefined>;
-    status: import("vue").Ref<import("../core/useRpc").Status>;
-}>;
+export declare function useNavigationTree({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'fetchNavigationTreeById'>;
 export {};

package/dist/runtime/composables/storefront/useNavigationTree.mjs

@@ -1,20 +1,13 @@
 import { useRpc } from "../core/useRpc.mjs";
-export async function useNavigationTree({
+export function useNavigationTree({
   params,
   options,
-  key = "useNavigationTree"
-} = {}) {
-  const { data, fetching, fetch, error, status } = await useRpc(
+  key: _key
+} = {}, key) {
+  return useRpc(
     "fetchNavigationTreeById",
-    key,
+    _key ?? key ?? "useNavigationTree",
     params,
     options
   );
-  return {
-    data,
-    fetching,
-    fetch,
-    error,
-    status
-  };
 }

package/dist/runtime/composables/storefront/useNavigationTrees.d.ts

@@ -1,16 +1,11 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { RpcOptions } from '../core/useRpc';
+import type { UseRpcReturn, UseRpcOptions } from '../core/useRpc';
 import type { MaybeRefOrGetter } from '#imports';
 type Options = Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'fetchAllNavigationTrees'>>;
-    options: RpcOptions;
+    options: UseRpcOptions<'fetchAllNavigationTrees'>;
+    /** @deprecated use the second argument of the composable to define the key */
     key: string;
 }>;
-export declare function useNavigationTrees({ params, options, key, }?: Options): Promise<{
-    data: import("vue").Ref<import("@scayle/storefront-api").NavigationAllEndpointResponseData | undefined>;
-    fetching: import("vue").Ref<boolean>;
-    fetch: () => Promise<void>;
-    error: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | undefined>;
-    status: import("vue").Ref<import("../core/useRpc").Status>;
-}>;
+export declare function useNavigationTrees({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'fetchAllNavigationTrees'>;
 export {};

package/dist/runtime/composables/storefront/useNavigationTrees.mjs

@@ -1,20 +1,13 @@
 import { useRpc } from "../core/useRpc.mjs";
-export async function useNavigationTrees({
+export function useNavigationTrees({
   params = {},
   options,
-  key = "useNavigationTrees"
-} = {}) {
-  const { data, fetching, fetch, error, status } = await useRpc(
+  key: _key
+} = {}, key) {
+  return useRpc(
     "fetchAllNavigationTrees",
-    key,
+    _key ?? key ?? "useNavigationTrees",
     params,
     options
   );
-  return {
-    data,
-    fetching,
-    fetch,
-    error,
-    status
-  };
 }

package/dist/runtime/composables/storefront/useOrder.d.ts

@@ -4,13 +4,14 @@ import type { MaybeRefOrGetter } from '#imports';
 type Options = Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getOrderById'>>;
     options: RpcOptions;
+    /** @deprecated use the second argument of the composable to define the key */
     key: string;
 }>;
 export declare function useOrder<P = {
     [k: string]: unknown;
 }, V = {
     [k: string]: unknown;
-}>({ params, options, key }?: Options): Promise<{
+}>({ params, options, key: _key }?: Options, key?: string): Promise<{
     data: Ref<Order & {
         items?: ({
             id?: number | undefined;
@@ -68,7 +69,7 @@ export declare function useOrder<P = {
                 [k: string]: unknown;
             };
             reservationKey?: string | undefined;
-            status: "available" | "cancelled" | "delivered" | "returned" | "unavailable";
+            status: "available" | "unavailable" | "cancelled" | "delivered" | "returned";
             variant: {
                 [k: string]: unknown;
             };
@@ -82,8 +83,8 @@ export declare function useOrder<P = {
         })[] | undefined;
     }>;
     fetching: import("vue").Ref<boolean>;
-    fetch: () => Promise<void>;
-    error: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | undefined>;
-    status: import("vue").Ref<import("../core/useRpc").Status>;
+    fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions | undefined) => Promise<void>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | null>;
+    status: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
 }>;
 export {};

package/dist/runtime/composables/storefront/useOrder.mjs

@@ -1,8 +1,8 @@
 import { useRpc } from "../core/useRpc.mjs";
-export async function useOrder({ params, options, key = "useOrder" } = {}) {
+export async function useOrder({ params, options, key: _key } = {}, key) {
   const { data, fetching, fetch, error, status } = await useRpc(
     "getOrderById",
-    key,
+    _key ?? key ?? "useOrder",
     params,
     options
   );

package/dist/runtime/composables/storefront/useOrderConfirmation.d.ts

@@ -4,13 +4,14 @@ import type { MaybeRefOrGetter } from '#imports';
 type Options = Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getOrderDataByCbd'>>;
     options: RpcOptions;
+    /** @deprecated use the second argument of the composable to define the key */
     key: string;
 }>;
 export declare function useOrderConfirmation<P = {
     [k: string]: unknown;
 }, V = {
     [k: string]: unknown;
-}>({ params, options, key }?: Options): Promise<{
+}>({ params, options, key: _key }?: Options, key?: string): Promise<{
     data: Ref<Order & {
         items?: ({
             id?: number | undefined;
@@ -68,7 +69,7 @@ export declare function useOrderConfirmation<P = {
                 [k: string]: unknown;
             };
             reservationKey?: string | undefined;
-            status: "available" | "cancelled" | "delivered" | "returned" | "unavailable";
+            status: "available" | "unavailable" | "cancelled" | "delivered" | "returned";
             variant: {
                 [k: string]: unknown;
             };
@@ -82,8 +83,8 @@ export declare function useOrderConfirmation<P = {
         })[] | undefined;
     }>;
     fetching: import("vue").Ref<boolean>;
-    fetch: () => Promise<void>;
-    error: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | undefined>;
-    status: import("vue").Ref<import("../core/useRpc").Status>;
+    fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions | undefined) => Promise<void>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | null>;
+    status: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
 }>;
 export {};

package/dist/runtime/composables/storefront/useOrderConfirmation.mjs

@@ -1,8 +1,8 @@
 import { useRpc } from "../core/useRpc.mjs";
-export async function useOrderConfirmation({ params, options, key = "useOrderConfirmation" } = {}) {
+export async function useOrderConfirmation({ params, options, key: _key } = {}, key) {
   const { data, fetching, fetch, error, status } = await useRpc(
     "getOrderDataByCbd",
-    key,
+    _key ?? key ?? "useOrderConfirmation",
     params,
     options
   );

package/dist/runtime/composables/storefront/useProduct.d.ts

@@ -1,16 +1,11 @@
 import { type RpcMethodParameters } from '@scayle/storefront-core';
-import { type RpcOptions } from '../core/useRpc';
+import { type UseRpcOptions, type UseRpcReturn } from '../core/useRpc';
 import { type MaybeRefOrGetter } from '#imports';
 type Options = Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getProductById'>>;
-    options: RpcOptions;
+    options: UseRpcOptions<'getProductById'>;
+    /** @deprecated use the second argument of the composable to define the key */
     key: string;
 }>;
-export declare function useProduct({ params, options, key, }?: Options): Promise<{
-    data: import("vue").Ref<import("@scayle/storefront-api").Product | undefined>;
-    fetching: import("vue").Ref<boolean>;
-    fetch: () => Promise<void>;
-    error: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | undefined>;
-    status: import("vue").Ref<import("../core/useRpc").Status>;
-}>;
+export declare function useProduct({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'getProductById'>;
 export {};

package/dist/runtime/composables/storefront/useProduct.mjs

@@ -1,20 +1,13 @@
 import { useRpc } from "../core/useRpc.mjs";
-export async function useProduct({
+export function useProduct({
   params,
   options,
-  key = "useProduct"
-} = {}) {
-  const { data, fetching, fetch, error, status } = await useRpc(
+  key: _key
+} = {}, key) {
+  return useRpc(
     "getProductById",
-    key,
+    _key ?? key ?? "useProduct",
     params,
     options
   );
-  return {
-    data,
-    fetching,
-    fetch,
-    error,
-    status
-  };
 }

package/dist/runtime/composables/storefront/useProducts.d.ts

@@ -1,28 +1,11 @@
 import { type RpcMethodParameters } from '@scayle/storefront-core';
-import { type RpcOptions } from '../core/useRpc';
+import { type UseRpcOptions, type UseRpcReturn } from '../core/useRpc';
 import { type MaybeRefOrGetter } from '#imports';
 type Options = Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getProductsByCategory'>>;
-    options: RpcOptions;
+    options: UseRpcOptions<'getProductsByCategory'>;
+    /** @deprecated use the second argument of the composable to define the key */
     key: string;
 }>;
-export declare function useProducts({ params, options, key, }?: Options): Promise<{
-    data: import("vue").Ref<{
-        products: import("@scayle/storefront-api").Product[];
-        pagination: {
-            current: number;
-            total: number;
-            perPage: number;
-            page: number;
-            first: number;
-            prev: number;
-            next: number;
-            last: number;
-        };
-    } | undefined>;
-    fetching: import("vue").Ref<boolean>;
-    fetch: () => Promise<void>;
-    error: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | undefined>;
-    status: import("vue").Ref<import("../core/useRpc").Status>;
-}>;
+export declare function useProducts({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'getProductsByCategory'>;
 export {};

package/dist/runtime/composables/storefront/useProducts.mjs

@@ -1,20 +1,13 @@
 import { useRpc } from "../core/useRpc.mjs";
-export async function useProducts({
+export function useProducts({
   params,
   options,
-  key = "useProducts"
-} = {}) {
-  const { data, fetching, fetch, error, status } = await useRpc(
+  key: _key
+} = {}, key) {
+  return useRpc(
     "getProductsByCategory",
-    key,
+    _key ?? key ?? "useProducts",
     params,
     options
   );
-  return {
-    data,
-    fetching,
-    fetch,
-    error,
-    status
-  };
 }

package/dist/runtime/composables/storefront/useProductsByIds.d.ts

@@ -1,16 +1,11 @@
 import { type RpcMethodParameters } from '@scayle/storefront-core';
-import { type RpcOptions } from '../core/useRpc';
+import { type UseRpcOptions, type UseRpcReturn } from '../core/useRpc';
 import { type MaybeRefOrGetter } from '#imports';
 type Options = Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getProductsByIds'>>;
-    options: RpcOptions;
+    options: UseRpcOptions<'getProductsByIds'>;
+    /** @deprecated use the second argument of the composable to define the key */
     key: string;
 }>;
-export declare function useProductsByIds({ params, options, key, }?: Options): Promise<{
-    data: import("vue").Ref<import("@scayle/storefront-api").Product[] | undefined>;
-    fetching: import("vue").Ref<boolean>;
-    fetch: () => Promise<void>;
-    error: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | undefined>;
-    status: import("vue").Ref<import("../core/useRpc").Status>;
-}>;
+export declare function useProductsByIds({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'getProductsByIds'>;
 export {};

package/dist/runtime/composables/storefront/useProductsByIds.mjs

@@ -1,20 +1,13 @@
 import { useRpc } from "../core/useRpc.mjs";
-export async function useProductsByIds({
+export function useProductsByIds({
   params,
   options,
-  key = "useProductsByIds"
-} = {}) {
-  const { data, fetching, fetch, error, status } = await useRpc(
+  key: _key
+} = {}, key) {
+  return useRpc(
     "getProductsByIds",
-    key,
+    _key ?? key ?? "useProductsByIds",
     params,
     options
   );
-  return {
-    data,
-    fetching,
-    fetch,
-    error,
-    status
-  };
 }