@scayle/storefront-nuxt 7.84.6 → 7.85.1

package/CHANGELOG.md

@@ -1,5 +1,90 @@
 # @scayle/storefront-nuxt
 
+## 7.85.1
+
+### Patch Changes
+
+- Fix `@vueuse/core` version to `11.0.3`
+
+## 7.85.0
+
+### Minor Changes
+
+- Fix typing when using `transform`, `default` or `pick` in RPC composables
+
+NOTE: This update corrects some broken typings and as a result may require some code changes.
+Previously many composables asserted that the default value would match the response value even when relying on the fallback `default` factory function: `() => null`.
+Due to this, the `data` property would be typed as `Ref<T>` even when it would be `Ref<null>` in case of error on a still pending request.
+The types have now been corrected to respect the `default` factory function's return and accurately represent the behavior.
+This means that you may have to add additional null checks in your code for typechecking to pass.
+
+For example:
+
+**In 7.84.6**
+
+```ts
+useBrand({
+  params: { brandId: 1 },
+}).data satisfies Ref<Brand>
+
+useBrand({
+  params: { brandId: 1 },
+  options: {
+    pick: ['id', 'isActive'],
+  },
+}).data satisfies Ref<Brand>
+
+useBrand({
+  params: { brandId: 1 },
+  options: {
+    transform: (brand) => brand.slug,
+  },
+}).data satisfies Ref<Brand>
+
+useBrand({
+  params: { brandId: 1 },
+  options: {
+    default: () => 'Brand not found',
+  },
+}).data satisfies Ref<Brand>
+```
+
+**In 7.85.0**
+
+```ts
+useBrand({
+  params: { brandId: 1 },
+}).data satisfies Ref<Brand | null>
+
+useBrand({
+  params: { brandId: 1 },
+  options: {
+    pick: ['id', 'isActive'],
+  },
+}).data satisfies Ref<Pick<Brand, 'id' | 'isActive'> | null>
+
+useBrand({
+  params: { brandId: 1 },
+  options: {
+    transform: (brand) => brand.slug,
+  },
+}).data satisfies Ref<string | null>
+
+useBrand({
+  params: { brandId: 1 },
+  options: {
+    default: () => 'Brand not found',
+  },
+}).data satisfies Ref<Brand | string>
+```
+
+For more details on `useAsyncData` usage check out the [Nuxt Docs](https://nuxt.com/docs/api/composables/use-async-data)
+
+### Patch Changes
+
+- Updated dependencies
+  - @scayle/storefront-core@7.64.3
+
 ## 7.84.6
 
 ### Patch Changes

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@scayle/storefront-nuxt",
-  "version": "7.84.6",
+  "version": "7.85.1",
   "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.6";
+const PACKAGE_VERSION = "7.85.1";
 const logger = createConsola({
   fancy: true,
   formatOptions: {

package/dist/runtime/composables/core/useIDP.mjs

@@ -23,7 +23,7 @@ export function useIDP(params = {}, key) {
     error,
     refresh,
     status,
-    // TODO: Deprecate the property here and remove it with the next major release
+    // TODO: [Next Major Release] Deprecate the property here and remove it with the next major release
     handleIDPLoginCallback
   });
 }

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

@@ -27,7 +27,7 @@ export function useBasket({
   const removeItemFromBasketRpc = useRpcCall("removeItemFromBasket");
   const asyncData = useRpc("getBasket", key, params, {
     server: false,
-    // TODO: In some cases it might be ok to fetch on server
+    // NOTE: In some cases it might be ok to fetch on server
     watch: [toRef(params)],
     dedupe: "defer",
     getCachedData: (key2) => {
@@ -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,19 +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>;
+    filters: import("vue").ComputedRef<import("@scayle/storefront-api").FiltersEndpointResponseData | undefined>;
     filtersFetching: import("vue").Ref<boolean>;
-    unfilteredCount: import("vue").ComputedRef<number>;
+    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;
-    }>;
+    } | null>;
     refreshProductCount: ({ where, }?: FilterParams) => Promise<void>;
     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[]>;
+    products: import("vue").ComputedRef<import("@scayle/storefront-api").Product[] | undefined>;
     pagination: import("vue").ComputedRef<{
         current: number;
         total: number;
@@ -37,12 +37,12 @@ export declare function useFacet({ key: optionsKey, params, }?: Options, _key?:
         prev: number;
         next: number;
         last: number;
-    }>;
+    } | undefined>;
     productsFetching: import("vue").Ref<boolean>;
     filterProducts: ({ where, page, sort, orFiltersOperator, }: FilterParams) => Promise<void>;
     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[]>;
+    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>;
     categoriesError: import("vue").Ref<any>;
@@ -54,19 +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>;
+    filters: import("vue").ComputedRef<import("@scayle/storefront-api").FiltersEndpointResponseData | undefined>;
     filtersFetching: import("vue").Ref<boolean>;
-    unfilteredCount: import("vue").ComputedRef<number>;
+    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;
-    }>;
+    } | null>;
     refreshProductCount: ({ where, }?: FilterParams) => Promise<void>;
     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[]>;
+    products: import("vue").ComputedRef<import("@scayle/storefront-api").Product[] | undefined>;
     pagination: import("vue").ComputedRef<{
         current: number;
         total: number;
@@ -76,12 +76,12 @@ export declare function useFacet({ key: optionsKey, params, }?: Options, _key?:
         prev: number;
         next: number;
         last: number;
-    }>;
+    } | undefined>;
     productsFetching: import("vue").Ref<boolean>;
     filterProducts: ({ where, page, sort, orFiltersOperator, }: FilterParams) => Promise<void>;
     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[]>;
+    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>;
     categoriesError: import("vue").Ref<any>;

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/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/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/dist/runtime/composables/storefront/useWishlist.mjs

@@ -23,7 +23,7 @@ export function useWishlist({
     params,
     {
       server: false,
-      // TODO: In some cases it might be ok to fetch on server
+      // NOTE: In some cases it might be ok to fetch on server
       watch: [toRef(params)],
       dedupe: "defer",
       getCachedData: (key2) => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@scayle/storefront-nuxt",
   "type": "module",
-  "version": "7.84.6",
+  "version": "7.85.1",
   "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.2",
+    "@scayle/storefront-core": "7.64.3",
     "@scayle/unstorage-compression-driver": "^0.1.3",
-    "@vueuse/core": "^10.11.0",
+    "@vueuse/core": "11.0.3",
     "consola": "^3.2.3",
     "core-js": "^3.37.1",
     "defu": "^6.1.4",
@@ -80,24 +80,24 @@
     "zod": "^3.23.8"
   },
   "devDependencies": {
-    "@nuxt/eslint": "0.5.0",
+    "@nuxt/eslint": "0.5.4",
     "@nuxt/module-builder": "0.5.5",
     "@nuxt/schema": "3.12.4",
     "@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.2",
     "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.1",
     "nuxt": "3.12.4",
     "publint": "0.2.10",
     "vitest": "2.0.5",
-    "vue-tsc": "2.0.29"
+    "vue-tsc": "2.1.2"
   },
   "peerDependencies": {
     "h3": "^1.10.0",
@@ -112,6 +112,6 @@
     "@nuxt/schema": "3.12.4"
   },
   "volta": {
-    "node": "20.16.0"
+    "node": "20.17.0"
   }
 }