@scayle/storefront-nuxt 7.84.5 → 7.85.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @scayle/storefront-nuxt
 
+## 7.85.0
+
+### Minor Changes
+
+- Improve typing when using `transform` or `pick` in RPC composables
+
+### Patch Changes
+
+- Updated dependencies
+  - @scayle/storefront-core@7.64.3
+
+## 7.84.6
+
+### Patch Changes
+
+- Updated dependencies
+  - @scayle/storefront-core@7.64.2
+
 ## 7.84.5
 
 ### Patch Changes

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@scayle/storefront-nuxt",
-  "version": "7.84.5",
+  "version": "7.85.0",
   "configKey": "storefront",
   "compatibility": {
     "nuxt": "^3.9.0"

package/dist/module.mjs

@@ -66,7 +66,7 @@ export default {
 }`;
 }
 const PACKAGE_NAME = "@scayle/storefront-nuxt";
-const PACKAGE_VERSION = "7.84.5";
+const PACKAGE_VERSION = "7.85.0";
 const logger = createConsola({
   fancy: true,
   formatOptions: {

package/dist/runtime/composables/core/useAvailableShops.d.ts

@@ -1,2 +1,2 @@
 import type { PublicShopConfig } from '../../../module';
-export declare function useAvailableShops(): import("vue").Ref<PublicShopConfig[], PublicShopConfig[]>;
+export declare function useAvailableShops(): import("vue").Ref<PublicShopConfig[]>;

package/dist/runtime/composables/core/useRpc.d.ts

@@ -2,23 +2,30 @@ import type { RpcContext, RpcMethodName, RpcMethodParameters, RpcMethodReturnTyp
 import type { AsyncDataOptions } from 'nuxt/app';
 import { useAsyncData } from 'nuxt/app';
 import type { MaybeRefOrGetter } from '#imports';
-type KeysOf<T> = Array<T extends T ? (keyof T extends string ? keyof T : never) : never>;
-export type RpcAsyncDataOptions<TResult> = AsyncDataOptions<TResult, TResult, KeysOf<TResult>, TResult>;
-export interface RpcOptions {
+export type KeysOf<T> = Array<T extends T ? (keyof T extends string ? keyof T : never) : never>;
+export type RpcOptions = {
     /** @deprecated use immediate instead */
     autoFetch?: boolean;
     lazy?: boolean;
-}
-export type UseRpcOptions<N extends RpcMethodName> = RpcOptions & RpcAsyncDataOptions<Exclude<Awaited<RpcMethodReturnType<N>>, Response>>;
-export type UseRpcReturn<N extends RpcMethodName> = ExtendedAsyncData<Exclude<Awaited<RpcMethodReturnType<N>>, Response>>;
+};
+/** The normalized return type of an RPC */
+export type NormalizedRpcResponse<N extends RpcMethodName> = Exclude<Awaited<RpcMethodReturnType<N>>, Response>;
+/**
+ * Extend AsyncDataOptions with autoFetch (deprecated) and lazy (unused)
+ */
+export type UseRpcOptions<N extends RpcMethodName, DataT = NormalizedRpcResponse<N>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null> = RpcOptions & AsyncDataOptions<NormalizedRpcResponse<N>, DataT, PickKeys, DefaultT>;
+/**
+ * The return type of a composable based on useRpc
+ */
+export type UseRpcReturn<N extends RpcMethodName, DataT = NormalizedRpcResponse<N>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null> = ExtendedAsyncData<NormalizedRpcResponse<N>, unknown, DataT, PickKeys, DefaultT>;
 export type Status = 'idle' | 'pending' | 'success' | 'error';
-type AsyncData<T> = ReturnType<typeof useAsyncData<T>>;
-type AwaitedAsyncData<T> = Awaited<AsyncData<T>>;
-type _ExtendedAsyncData<T> = AwaitedAsyncData<T> & {
-    fetching: AwaitedAsyncData<T>['pending'];
-    fetch: AwaitedAsyncData<T>['refresh'];
+type AsyncData<ResT, ErrorT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null> = ReturnType<typeof useAsyncData<ResT, ErrorT, DataT, PickKeys, DefaultT>>;
+type AwaitedAsyncData<ResT, ErrorT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null> = Awaited<AsyncData<ResT, ErrorT, DataT, PickKeys, DefaultT>>;
+type _ExtendedAsyncData<ResT, ErrorT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null> = AwaitedAsyncData<ResT, ErrorT, DataT, PickKeys, DefaultT> & {
+    fetching: AwaitedAsyncData<ResT, ErrorT, DataT, PickKeys, DefaultT>['pending'];
+    fetch: AwaitedAsyncData<ResT, ErrorT, DataT, PickKeys, DefaultT>['refresh'];
 };
-export type ExtendedAsyncData<T> = _ExtendedAsyncData<T> & Promise<_ExtendedAsyncData<T>>;
+export type ExtendedAsyncData<ResT, ErrorT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null> = _ExtendedAsyncData<ResT, ErrorT, DataT, PickKeys, DefaultT> & Promise<_ExtendedAsyncData<ResT, ErrorT, DataT, PickKeys, DefaultT>>;
 /**
  * `useRpc` is a wrapper around `useAsyncData` for registered RPC methods
  *
@@ -43,5 +50,5 @@ export type ExtendedAsyncData<T> = _ExtendedAsyncData<T> & Promise<_ExtendedAsyn
  * But anything passed here will take precedence.
  * @see {@link https://nuxt.com/docs/api/composables/use-async-data#params}
  */
-export declare function useRpc<N extends RpcMethodName, P extends RpcMethodParameters<N>, TResult extends Exclude<Awaited<RpcMethodReturnType<N>>, Response>, TParams = P extends RpcContext ? undefined : P>(method: N, key: string, params?: MaybeRefOrGetter<TParams>, options?: RpcAsyncDataOptions<TResult> & RpcOptions): ExtendedAsyncData<TResult>;
+export declare function useRpc<N extends RpcMethodName, DataT = NormalizedRpcResponse<N>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>(method: N, key: string, params?: MaybeRefOrGetter<RpcMethodParameters<N> extends RpcContext ? undefined : RpcMethodParameters<N>>, options?: UseRpcOptions<N, DataT, PickKeys, DefaultT>): ExtendedAsyncData<NormalizedRpcResponse<N>, unknown, DataT, PickKeys, DefaultT>;
 export {};

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

@@ -32,13 +32,13 @@ type UseBasketBaseReturn = Awaited<UseRpcReturn<'getBasket'>> & {
     removeItemByKey: (itemKey: string) => Promise<void>;
     clear: () => Promise<void>;
     products: ComputedRef<Product[]>;
-    count: ComputedRef<number>;
-    countWithoutSoldOutItems: ComputedRef<number>;
-    items: ComputedRef<BasketItem[]>;
-    cost: ComputedRef<BasketTotalPrice>;
-    key: ComputedRef<BasketKey>;
+    count: ComputedRef<number | undefined>;
+    countWithoutSoldOutItems: ComputedRef<number | undefined>;
+    items: ComputedRef<BasketItem[] | undefined>;
+    cost: ComputedRef<BasketTotalPrice | undefined>;
+    key: ComputedRef<BasketKey | undefined>;
     isEmpty: ComputedRef<boolean>;
-    packages: ComputedRef<BasketPackageInformation[]>;
+    packages: ComputedRef<BasketPackageInformation[] | undefined>;
     shippingDates: ComputedRef<(string | null)[] | undefined>;
 };
 export declare function useBasket({ params, key, }?: UseBasketOptions): UseBasketBaseReturn & Promise<UseBasketBaseReturn>;

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

@@ -125,7 +125,7 @@ export function useBasket({
     () => {
       const mainItemQuantities = /* @__PURE__ */ new Map();
       const soldOutItemGroups = /* @__PURE__ */ new Set();
-      let count2 = data.value?.items?.reduce((prev, current) => {
+      let count2 = (data.value?.items ?? []).reduce((prev, current) => {
         if (current.itemGroup?.id) {
           if (current.itemGroup.isMainItem) {
             mainItemQuantities.set(current.itemGroup.id, current.quantity);

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

@@ -1,11 +1,9 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { UseRpcOptions, UseRpcReturn } from '../core/useRpc';
+import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc';
 import type { MaybeRefOrGetter } from '#imports';
-type Options = Partial<{
+export declare function useBrand<DataT = NormalizedRpcResponse<'getBrandById'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getBrandById'>>;
-    options: UseRpcOptions<'getBrandById'>;
+    options: UseRpcOptions<'getBrandById', DataT, PickKeys, DefaultT>;
     /** @deprecated use the second argument of the composable to define the key */
     key: string;
-}>;
-export declare function useBrand({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'getBrandById'>;
-export {};
+}>, key?: string): UseRpcReturn<'getBrandById', DataT, PickKeys, DefaultT>;

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

@@ -1,11 +1,9 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { UseRpcOptions, UseRpcReturn } from '../core/useRpc';
+import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc';
 import type { MaybeRefOrGetter } from '#imports';
-type Options = Partial<{
+export declare function useBrands<DataT = NormalizedRpcResponse<'getBrands'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getBrands'>>;
-    options: UseRpcOptions<'getBrands'>;
+    options: UseRpcOptions<'getBrands', DataT, PickKeys, DefaultT>;
     /** @deprecated use the second argument of the composable to define the key */
     key: string;
-}>;
-export declare function useBrands({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'getBrands'>;
-export {};
+}>, key?: string): UseRpcReturn<'getBrands', DataT, PickKeys, DefaultT>;

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

@@ -1,14 +1,13 @@
 import type { RpcMethodParameters, RpcMethodReturnType } from '@scayle/storefront-core';
-import { type UseRpcOptions, type UseRpcReturn } from '../core/useRpc';
+import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc';
 import type { MaybeRefOrGetter } from '#imports';
-type Options = Partial<{
+type UseCategoriesBaseReturn<DataT, PickKeys extends KeysOf<DataT>, DefaultT> = Pick<Awaited<UseRpcReturn<'getCategoriesByPath', DataT, PickKeys, DefaultT>>, 'data' | 'error' | 'status' | 'fetch' | 'fetching' | 'refresh'> & {
+    getCategoryById: (id: number, includeHidden?: true) => RpcMethodReturnType<'getCategoryById'>;
+};
+export declare function useCategories<DataT = NormalizedRpcResponse<'getCategoriesByPath'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getCategoriesByPath'>>;
-    options: UseRpcOptions<'getCategoriesByPath'>;
+    options: UseRpcOptions<'getCategoriesByPath', DataT, PickKeys, DefaultT>;
     /** @deprecated use the second argument of the composable to define the key */
     key: string;
-}>;
-type UseCategoriesBaseReturn = Pick<Awaited<UseRpcReturn<'getCategoriesByPath'>>, 'data' | 'error' | 'status' | 'fetch' | 'fetching' | 'refresh'> & {
-    getCategoryById: (id: number, includeHidden?: true) => RpcMethodReturnType<'getCategoryById'>;
-};
-export declare function useCategories({ params, options, key: _key, }?: Options, key?: string): UseCategoriesBaseReturn & Promise<UseCategoriesBaseReturn>;
+}>, key?: string): UseCategoriesBaseReturn<DataT, PickKeys, DefaultT> & Promise<UseCategoriesBaseReturn<DataT, PickKeys, DefaultT>>;
 export {};

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

@@ -1,11 +1,9 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { UseRpcOptions, UseRpcReturn } from '../core/useRpc';
+import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc';
 import type { MaybeRefOrGetter } from '#imports';
-type Options = Partial<{
+export declare function useCategoryById<DataT = NormalizedRpcResponse<'getCategoryById'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getCategoryById'>>;
-    options: UseRpcOptions<'getCategoryById'>;
+    options: UseRpcOptions<'getCategoryById', DataT, PickKeys, DefaultT>;
     /** @deprecated use the second argument of the composable to define the key */
     key: string;
-}>;
-export declare function useCategoryById({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'getCategoryById'>;
-export {};
+}>, key?: string): UseRpcReturn<'getCategoryById', DataT, PickKeys, DefaultT>;

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

@@ -1,11 +1,9 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { UseRpcOptions, UseRpcReturn } from '../core/useRpc';
+import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc';
 import type { MaybeRefOrGetter } from '#imports';
-type Options = {
+export declare function useCategoryByPath<DataT = NormalizedRpcResponse<'getCategoryByPath'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }: {
     params: MaybeRefOrGetter<RpcMethodParameters<'getCategoryByPath'>>;
-    options?: UseRpcOptions<'getCategoryByPath'>;
+    options?: UseRpcOptions<'getCategoryByPath', DataT, PickKeys, DefaultT>;
     /** @deprecated use the second argument of the composable to define the key */
     key: string;
-};
-export declare function useCategoryByPath({ params, options, key: _key, }: Options, key?: string): UseRpcReturn<'getCategoryByPath'>;
-export {};
+}, key?: string): UseRpcReturn<'getCategoryByPath', DataT, PickKeys, DefaultT>;

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

@@ -1,11 +1,9 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import { type UseRpcOptions, type UseRpcReturn } from '../core/useRpc';
+import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc';
 import type { MaybeRefOrGetter } from '#imports';
-type Options = Partial<{
+export declare function useCurrentPromotions<DataT = NormalizedRpcResponse<'getCurrentPromotions'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getCurrentPromotions'>>;
-    options: UseRpcOptions<'getCurrentPromotions'>;
+    options: UseRpcOptions<'getCurrentPromotions', DataT, PickKeys, DefaultT>;
     /** @deprecated use the second argument of the composable to define the key */
     key: string;
-}>;
-export declare function useCurrentPromotions({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'getCurrentPromotions'>;
-export {};
+}>, key?: string): UseRpcReturn<'getCurrentPromotions', DataT, PickKeys, DefaultT>;

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

@@ -15,21 +15,19 @@ type Options = Partial<{
     key: string;
 }>;
 export declare function useFacet({ key: optionsKey, params, }?: Options, _key?: string): {
-    filters: import("vue").ComputedRef<import("@scayle/storefront-api").FiltersEndpointResponseData>;
-    filtersFetching: import("vue").Ref<boolean, boolean>;
-    unfilteredCount: import("vue").ComputedRef<number>;
-    filterStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus, import("nuxt/app").AsyncDataRequestStatus>;
-    filterError: import("vue").Ref<any, any>;
+    filters: import("vue").ComputedRef<import("@scayle/storefront-api").FiltersEndpointResponseData | undefined>;
+    filtersFetching: import("vue").Ref<boolean>;
+    unfilteredCount: import("vue").ComputedRef<number | undefined>;
+    filterStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
+    filterError: import("vue").Ref<any>;
     productCountData: import("vue").Ref<{
         count: number;
-    }, {
-        count: number;
-    }>;
+    } | null>;
     refreshProductCount: ({ where, }?: FilterParams) => Promise<void>;
-    productCountFetching: import("vue").Ref<boolean, boolean>;
-    productCountError: import("vue").Ref<any, any>;
-    productCountStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus, import("nuxt/app").AsyncDataRequestStatus>;
-    products: import("vue").ComputedRef<import("@scayle/storefront-api").Product[]>;
+    productCountFetching: import("vue").Ref<boolean>;
+    productCountError: import("vue").Ref<any>;
+    productCountStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
+    products: import("vue").ComputedRef<import("@scayle/storefront-api").Product[] | undefined>;
     pagination: import("vue").ComputedRef<{
         current: number;
         total: number;
@@ -39,16 +37,16 @@ export declare function useFacet({ key: optionsKey, params, }?: Options, _key?:
         prev: number;
         next: number;
         last: number;
-    }>;
-    productsFetching: import("vue").Ref<boolean, boolean>;
+    } | undefined>;
+    productsFetching: import("vue").Ref<boolean>;
     filterProducts: ({ where, page, sort, orFiltersOperator, }: FilterParams) => Promise<void>;
-    productError: import("vue").Ref<any, any>;
-    productStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus, import("nuxt/app").AsyncDataRequestStatus>;
-    categories: import("vue").ComputedRef<import("@scayle/storefront-api").Category | import("@scayle/storefront-api").Category[]>;
+    productError: import("vue").Ref<any>;
+    productStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
+    categories: import("vue").ComputedRef<import("@scayle/storefront-api").Category | import("@scayle/storefront-api").Category[] | undefined>;
     selectedCategory: import("vue").ComputedRef<import("@scayle/storefront-api").Category | undefined>;
-    categoriesFetching: import("vue").Ref<boolean, boolean>;
-    categoriesError: import("vue").Ref<any, any>;
-    categoriesStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus, import("nuxt/app").AsyncDataRequestStatus>;
+    categoriesFetching: import("vue").Ref<boolean>;
+    categoriesError: import("vue").Ref<any>;
+    categoriesStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
     fetchProducts: ({ path, page, perPage, where, sort, pricePromotionKey, cache, orFiltersOperator, }: FilterParams & {
         path: string;
         pricePromotionKey?: string;
@@ -56,21 +54,19 @@ export declare function useFacet({ key: optionsKey, params, }?: Options, _key?:
     }) => Promise<true | undefined>;
     fetchPage: (pageToFetch: number) => Promise<void>;
 } & Promise<{
-    filters: import("vue").ComputedRef<import("@scayle/storefront-api").FiltersEndpointResponseData>;
-    filtersFetching: import("vue").Ref<boolean, boolean>;
-    unfilteredCount: import("vue").ComputedRef<number>;
-    filterStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus, import("nuxt/app").AsyncDataRequestStatus>;
-    filterError: import("vue").Ref<any, any>;
+    filters: import("vue").ComputedRef<import("@scayle/storefront-api").FiltersEndpointResponseData | undefined>;
+    filtersFetching: import("vue").Ref<boolean>;
+    unfilteredCount: import("vue").ComputedRef<number | undefined>;
+    filterStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
+    filterError: import("vue").Ref<any>;
     productCountData: import("vue").Ref<{
         count: number;
-    }, {
-        count: number;
-    }>;
+    } | null>;
     refreshProductCount: ({ where, }?: FilterParams) => Promise<void>;
-    productCountFetching: import("vue").Ref<boolean, boolean>;
-    productCountError: import("vue").Ref<any, any>;
-    productCountStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus, import("nuxt/app").AsyncDataRequestStatus>;
-    products: import("vue").ComputedRef<import("@scayle/storefront-api").Product[]>;
+    productCountFetching: import("vue").Ref<boolean>;
+    productCountError: import("vue").Ref<any>;
+    productCountStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
+    products: import("vue").ComputedRef<import("@scayle/storefront-api").Product[] | undefined>;
     pagination: import("vue").ComputedRef<{
         current: number;
         total: number;
@@ -80,16 +76,16 @@ export declare function useFacet({ key: optionsKey, params, }?: Options, _key?:
         prev: number;
         next: number;
         last: number;
-    }>;
-    productsFetching: import("vue").Ref<boolean, boolean>;
+    } | undefined>;
+    productsFetching: import("vue").Ref<boolean>;
     filterProducts: ({ where, page, sort, orFiltersOperator, }: FilterParams) => Promise<void>;
-    productError: import("vue").Ref<any, any>;
-    productStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus, import("nuxt/app").AsyncDataRequestStatus>;
-    categories: import("vue").ComputedRef<import("@scayle/storefront-api").Category | import("@scayle/storefront-api").Category[]>;
+    productError: import("vue").Ref<any>;
+    productStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
+    categories: import("vue").ComputedRef<import("@scayle/storefront-api").Category | import("@scayle/storefront-api").Category[] | undefined>;
     selectedCategory: import("vue").ComputedRef<import("@scayle/storefront-api").Category | undefined>;
-    categoriesFetching: import("vue").Ref<boolean, boolean>;
-    categoriesError: import("vue").Ref<any, any>;
-    categoriesStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus, import("nuxt/app").AsyncDataRequestStatus>;
+    categoriesFetching: import("vue").Ref<boolean>;
+    categoriesError: import("vue").Ref<any>;
+    categoriesStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
     fetchProducts: ({ path, page, perPage, where, sort, pricePromotionKey, cache, orFiltersOperator, }: FilterParams & {
         path: string;
         pricePromotionKey?: string;

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

@@ -1,11 +1,9 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { UseRpcOptions, UseRpcReturn } from '../core/useRpc';
+import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc';
 import type { MaybeRefOrGetter } from '#imports';
-type Options = Partial<{
+export declare function useFilters<DataT = NormalizedRpcResponse<'getFilters'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getFilters'>>;
-    options: UseRpcOptions<'getFilters'>;
+    options: UseRpcOptions<'getFilters', DataT, PickKeys, DefaultT>;
     /** @deprecated use the second argument of the composable to define the key */
     key: string;
-}>;
-export declare function useFilters({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'getFilters'>;
-export {};
+}>, key?: string): UseRpcReturn<'getFilters', DataT, PickKeys, DefaultT>;

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

@@ -1,11 +1,9 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { UseRpcOptions, UseRpcReturn } from '../core/useRpc';
+import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc';
 import type { MaybeRefOrGetter } from '#imports';
-type Options = Partial<{
+export declare function useNavigationTree<DataT = NormalizedRpcResponse<'fetchNavigationTreeById'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'fetchNavigationTreeById'>>;
-    options: UseRpcOptions<'fetchNavigationTreeById'>;
+    options: UseRpcOptions<'fetchNavigationTreeById', DataT, PickKeys, DefaultT>;
     /** @deprecated use the second argument of the composable to define the key */
     key: string;
-}>;
-export declare function useNavigationTree({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'fetchNavigationTreeById'>;
-export {};
+}>, key?: string): UseRpcReturn<'fetchNavigationTreeById', DataT, PickKeys, DefaultT>;

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

@@ -1,11 +1,9 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { UseRpcReturn, UseRpcOptions } from '../core/useRpc';
+import type { UseRpcReturn, UseRpcOptions, NormalizedRpcResponse, KeysOf } from '../core/useRpc';
 import type { MaybeRefOrGetter } from '#imports';
-type Options = Partial<{
+export declare function useNavigationTrees<DataT = NormalizedRpcResponse<'fetchAllNavigationTrees'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'fetchAllNavigationTrees'>>;
-    options: UseRpcOptions<'fetchAllNavigationTrees'>;
+    options: UseRpcOptions<'fetchAllNavigationTrees', DataT, PickKeys, DefaultT>;
     /** @deprecated use the second argument of the composable to define the key */
     key: string;
-}>;
-export declare function useNavigationTrees({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'fetchAllNavigationTrees'>;
-export {};
+}>, key?: string): UseRpcReturn<'fetchAllNavigationTrees', DataT, PickKeys, DefaultT>;

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

@@ -1,11 +1,9 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import { type UseRpcOptions, type UseRpcReturn } from '../core/useRpc';
+import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc';
 import type { MaybeRefOrGetter } from '#imports';
-type Options = Partial<{
+export declare function useProduct<DataT = NormalizedRpcResponse<'getProductById'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getProductById'>>;
-    options: UseRpcOptions<'getProductById'>;
+    options: UseRpcOptions<'getProductById', DataT, PickKeys, DefaultT>;
     /** @deprecated use the second argument of the composable to define the key */
     key: string;
-}>;
-export declare function useProduct({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'getProductById'>;
-export {};
+}>, key?: string): UseRpcReturn<'getProductById', DataT, PickKeys, DefaultT>;

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

@@ -1,11 +1,9 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import { type UseRpcOptions, type UseRpcReturn } from '../core/useRpc';
+import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc';
 import type { MaybeRefOrGetter } from '#imports';
-type Options = Partial<{
+export declare function useProducts<DataT = NormalizedRpcResponse<'getProductsByCategory'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getProductsByCategory'>>;
-    options: UseRpcOptions<'getProductsByCategory'>;
+    options: UseRpcOptions<'getProductsByCategory', DataT, PickKeys, DefaultT>;
     /** @deprecated use the second argument of the composable to define the key */
     key: string;
-}>;
-export declare function useProducts({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'getProductsByCategory'>;
-export {};
+}>, key?: string): UseRpcReturn<'getProductsByCategory', DataT, PickKeys, DefaultT>;

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

@@ -1,11 +1,9 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import { type UseRpcOptions, type UseRpcReturn } from '../core/useRpc';
+import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc';
 import type { MaybeRefOrGetter } from '#imports';
-type Options = Partial<{
+export declare function useProductsByIds<DataT = NormalizedRpcResponse<'getProductsByIds'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getProductsByIds'>>;
-    options: UseRpcOptions<'getProductsByIds'>;
+    options: UseRpcOptions<'getProductsByIds', DataT, PickKeys, DefaultT>;
     /** @deprecated use the second argument of the composable to define the key */
     key: string;
-}>;
-export declare function useProductsByIds({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'getProductsByIds'>;
-export {};
+}>, key?: string): UseRpcReturn<'getProductsByIds', DataT, PickKeys, DefaultT>;

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

@@ -1,11 +1,9 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import { type UseRpcOptions, type UseRpcReturn } from '../core/useRpc';
+import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc';
 import type { MaybeRefOrGetter } from '#imports';
-type Options = Partial<{
+export declare function useProductsByReferenceKeys<DataT = NormalizedRpcResponse<'getProductsByReferenceKeys'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getProductsByReferenceKeys'>>;
-    options: UseRpcOptions<'getProductsByReferenceKeys'>;
+    options: UseRpcOptions<'getProductsByReferenceKeys', DataT, PickKeys, DefaultT>;
     /** @deprecated use the second argument of the composable to define the key */
     key: string;
-}>;
-export declare function useProductsByReferenceKeys({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'getProductsByReferenceKeys'>;
-export {};
+}>, key?: string): UseRpcReturn<'getProductsByReferenceKeys', DataT, PickKeys, DefaultT>;

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

@@ -1,11 +1,9 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { UseRpcOptions, UseRpcReturn } from '../core/useRpc';
+import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc';
 import type { MaybeRefOrGetter } from '#imports';
-type Options = Partial<{
+export declare function useProductsCount<DataT = NormalizedRpcResponse<'getProductsCount'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getProductsCount'>>;
-    options: UseRpcOptions<'getProductsCount'>;
+    options: UseRpcOptions<'getProductsCount', DataT, PickKeys, DefaultT>;
     /** @deprecated use the second argument of the composable to define the key */
     key: string;
-}>;
-export declare function useProductsCount({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'getProductsCount'>;
-export {};
+}>, key?: string): UseRpcReturn<'getProductsCount', DataT, PickKeys, DefaultT>;

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

@@ -1,11 +1,9 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import { type UseRpcOptions, type UseRpcReturn } from '../core/useRpc';
+import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc';
 import type { MaybeRefOrGetter } from '#imports';
-type Options = Partial<{
+export declare function usePromotions<DataT = NormalizedRpcResponse<'getPromotions'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getPromotions'>>;
-    options: UseRpcOptions<'getPromotions'>;
+    options: UseRpcOptions<'getPromotions', DataT, PickKeys, DefaultT>;
     /** @deprecated use the second argument of the composable to define the key */
     key: string;
-}>;
-export declare function usePromotions({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'getPromotions'>;
-export {};
+}>, key?: string): UseRpcReturn<'getPromotions', DataT, PickKeys, DefaultT>;

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

@@ -1,11 +1,9 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import { type UseRpcOptions, type UseRpcReturn } from '../core/useRpc';
+import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc';
 import type { MaybeRefOrGetter } from '#imports';
-type Options = Partial<{
+export declare function usePromotionsByIds<DataT = NormalizedRpcResponse<'getPromotionsByIds'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getPromotionsByIds'>>;
-    options: UseRpcOptions<'getPromotionsByIds'>;
+    options: UseRpcOptions<'getPromotionsByIds', DataT, PickKeys, DefaultT>;
     /** @deprecated use the second argument of the composable to define the key */
     key: string;
-}>;
-export declare function usePromotionsByIds({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'getPromotionsByIds'>;
-export {};
+}>, key?: string): UseRpcReturn<'getPromotionsByIds', DataT, PickKeys, DefaultT>;

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

@@ -5,9 +5,9 @@ type Options = Partial<{
 }>;
 /** @deprecated `useSearch` is deprecated. Please, use `useSearchSuggestions` or `useSearchResolve` */
 export declare function useSearch({ params, key }?: Options): {
-    data: import("vue").Ref<TypeaheadSuggestionsEndpointResponseData | undefined, TypeaheadSuggestionsEndpointResponseData | undefined>;
-    pending: import("vue").Ref<boolean, boolean>;
-    searchQuery: import("vue").Ref<string, string>;
+    data: import("vue").Ref<TypeaheadSuggestionsEndpointResponseData | undefined>;
+    pending: import("vue").Ref<boolean>;
+    searchQuery: import("vue").Ref<string>;
     resetSearch: () => void;
     search: ({ term, slug, productLimit }: SearchInput) => Promise<void>;
 };

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

@@ -1,8 +1,6 @@
-import type { UseRpcOptions, UseRpcReturn } from '../core/useRpc';
-type Options = Partial<{
-    options: UseRpcOptions<'getShopConfiguration'>;
+import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc';
+export declare function useShopConfiguration<DataT = NormalizedRpcResponse<'getShopConfiguration'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ options, key: _key, }?: Partial<{
+    options: UseRpcOptions<'getShopConfiguration', DataT, PickKeys, DefaultT>;
     /** @deprecated use the second argument of the composable to define the key */
     key: string;
-}>;
-export declare function useShopConfiguration({ options, key: _key, }?: Options, key?: string): UseRpcReturn<'getShopConfiguration'>;
-export {};
+}>, key?: string): UseRpcReturn<'getShopConfiguration', DataT, PickKeys, DefaultT>;

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

@@ -8,8 +8,8 @@ export type SearchOptions = Partial<{
     key: string;
 }>;
 export declare function useStorefrontSearch(searchQuery: Ref<string>, { params, key }?: SearchOptions): {
-    data: import("vue").Ref<SearchV2SuggestionsEndpointResponseData | undefined, SearchV2SuggestionsEndpointResponseData | undefined>;
-    pending: import("vue").Ref<boolean, boolean>;
+    data: import("vue").Ref<SearchV2SuggestionsEndpointResponseData | undefined>;
+    pending: import("vue").Ref<boolean>;
     resetSearch: () => void;
     getSearchSuggestions: () => Promise<void>;
     resolveSearch: () => Promise<import("@scayle/storefront-api").SearchEntity | null | undefined>;

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

@@ -1,8 +1,6 @@
-import type { UseRpcOptions, UseRpcReturn } from '../core/useRpc';
-type Options = Partial<{
-    options: UseRpcOptions<'getShopUserAddresses'>;
+import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc';
+export declare function useUserAddresses<DataT = NormalizedRpcResponse<'getShopUserAddresses'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ options, key: _key, }?: Partial<{
+    options: UseRpcOptions<'getShopUserAddresses', DataT, PickKeys, DefaultT>;
     /** @deprecated use the second argument of the composable to define the key */
     key: string;
-}>;
-export declare function useUserAddresses({ options, key: _key, }?: Options, key?: string): UseRpcReturn<'getShopUserAddresses'>;
-export {};
+}>, key?: string): UseRpcReturn<'getShopUserAddresses', DataT, PickKeys, DefaultT>;

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

@@ -1,11 +1,9 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import { type UseRpcOptions, type UseRpcReturn } from '../core/useRpc';
+import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc';
 import type { MaybeRefOrGetter } from '#imports';
-type Options = Partial<{
+export declare function useVariant<DataT = NormalizedRpcResponse<'getVariantById'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getVariantById'>>;
-    options: UseRpcOptions<'getVariantById'>;
+    options: UseRpcOptions<'getVariantById', DataT, PickKeys, DefaultT>;
     /** @deprecated use the second argument of the composable to define the key */
     key: string;
-}>;
-export declare function useVariant({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'getVariantById'>;
-export {};
+}>, key?: string): UseRpcReturn<'getVariantById', DataT, PickKeys, DefaultT>;

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

@@ -36,8 +36,8 @@ type UseWishlistBaseReturn = Awaited<UseRpcReturn<'getWishlist'>> & {
         variantId?: number;
         productId?: number;
     }) => Promise<void>;
-    count: ComputedRef<number>;
-    items: ComputedRef<WishlistItem[]>;
+    count: ComputedRef<number | undefined>;
+    items: ComputedRef<WishlistItem[] | undefined>;
     products: ComputedRef<Product[]>;
 };
 export declare function useWishlist({ params, key, }?: Options): UseWishlistBaseReturn & Promise<UseWishlistBaseReturn>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@scayle/storefront-nuxt",
   "type": "module",
-  "version": "7.84.5",
+  "version": "7.85.0",
   "description": "Nuxt integration for the SCAYLE Commerce Engine and Storefront API",
   "author": "SCAYLE Commerce Engine",
   "license": "MIT",
@@ -60,9 +60,9 @@
     "@nuxt/kit": "^3.12.2",
     "@opentelemetry/api": "^1.9.0",
     "@scayle/h3-session": "^0.4.0",
-    "@scayle/storefront-core": "7.64.1",
+    "@scayle/storefront-core": "7.64.3",
     "@scayle/unstorage-compression-driver": "^0.1.3",
-    "@vueuse/core": "^10.11.0",
+    "@vueuse/core": "^11.0.0",
     "consola": "^3.2.3",
     "core-js": "^3.37.1",
     "defu": "^6.1.4",
@@ -80,22 +80,22 @@
     "zod": "^3.23.8"
   },
   "devDependencies": {
-    "@nuxt/eslint": "0.5.0",
+    "@nuxt/eslint": "0.5.3",
     "@nuxt/module-builder": "0.5.5",
     "@nuxt/schema": "3.12.4",
-    "@nuxt/test-utils": "3.14.0",
+    "@nuxt/test-utils": "3.14.1",
     "@scayle/eslint-config-storefront": "4.3.0",
     "@scayle/eslint-plugin-vue-composable": "0.2.0",
-    "@types/node": "20.14.15",
+    "@types/node": "20.16.1",
     "dprint": "0.47.2",
-    "eslint": "9.9.0",
+    "eslint": "9.9.1",
     "eslint-formatter-gitlab": "5.1.0",
     "fishery": "2.2.2",
     "h3": "1.12.0",
     "node-mocks-http": "1.15.1",
-    "nuxi": "3.12.0",
+    "nuxi": "3.13.0",
     "nuxt": "3.12.4",
-    "publint": "0.2.9",
+    "publint": "0.2.10",
     "vitest": "2.0.5",
     "vue-tsc": "2.0.29"
   },
@@ -107,11 +107,11 @@
   },
   "resolutions": {
     "h3": "1.12.0",
-    "vue": "3.4.37",
+    "vue": "3.4.38",
     "@nuxt/kit": "3.12.4",
     "@nuxt/schema": "3.12.4"
   },
   "volta": {
-    "node": "20.16.0"
+    "node": "20.17.0"
   }
 }