@scayle/storefront-nuxt 7.95.4 → 8.0.0

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

@@ -1,12 +1,11 @@
 import { useRpc } from "../core/useRpc.js";
 export function useFilters({
   params,
-  options,
-  key: _key
-} = {}, key) {
+  options
+} = {}, key = "useFilters") {
   return useRpc(
     "getFilters",
-    _key ?? key ?? "useFilters",
+    key,
     params,
     options
   );

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

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

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

@@ -1,25 +1,22 @@
 import { useRpc } from "../core/useRpc.js";
 export function useNavigationTreeById({
   params,
-  options,
-  key: _key
-} = {}, key) {
+  options
+} = {}, key = "useNavigationTreeById") {
   return useRpc(
     "fetchNavigationTreeById",
-    _key ?? key ?? "useNavigationTreeById",
+    key,
     params,
     options
   );
 }
-export const useNavigationTree = useNavigationTreeById;
 export function useNavigationTreeByName({
   params,
-  options,
-  key: _key
-} = {}, key) {
+  options
+} = {}, key = "useNavigationTreeByName") {
   return useRpc(
     "fetchNavigationTreeByName",
-    _key ?? key ?? "useNavigationTreeByName",
+    key,
     params,
     options
   );

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

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

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

@@ -1,12 +1,11 @@
 import { useRpc } from "../core/useRpc.js";
 export function useNavigationTrees({
   params = {},
-  options,
-  key: _key
-} = {}, key) {
+  options
+} = {}, key = "useNavigationTrees") {
   return useRpc(
     "fetchAllNavigationTrees",
-    _key ?? key ?? "useNavigationTrees",
+    key,
     params,
     options
   );

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

@@ -1,6 +1,6 @@
 import type { RpcMethodParameters, Order } from '@scayle/storefront-core';
 import type { AsyncDataOptions } from 'nuxt/app';
-import { type RpcOptions, type KeysOf, type ExtendedAsyncData } from '../core/useRpc.js';
+import { type KeysOf, type ExtendedAsyncData } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
 type ItemsType = Exclude<Order['items'], undefined>;
 type NewItemsType<P, V> = Exclude<ItemsType[number], 'product' | 'variant'> & {
@@ -13,13 +13,11 @@ export declare function useOrder<P = {
     [k: string]: unknown;
 }, DataT = Order & {
     items?: NewItemsType<P, V>[];
-}, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key }?: {
+}, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options }?: {
     params?: MaybeRefOrGetter<RpcMethodParameters<'getOrderById'>>;
-    options?: RpcOptions & AsyncDataOptions<Order & {
+    options?: AsyncDataOptions<Order & {
         items?: NewItemsType<P, V>[];
     }, DataT, PickKeys, DefaultT>;
-    /** @deprecated use the second argument of the composable to define the key */
-    key?: string;
 }, key?: string): ExtendedAsyncData<Order & {
     items?: NewItemsType<P, V>[];
 }, unknown, DataT, PickKeys, DefaultT>;

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

@@ -1,10 +1,8 @@
-import {
-  useRpc
-} from "../core/useRpc.js";
-export function useOrder({ params, options, key: _key } = {}, key) {
+import { useRpc } from "../core/useRpc.js";
+export function useOrder({ params, options } = {}, key = "useOrder") {
   return useRpc(
     "getOrderById",
-    _key ?? key ?? "useOrder",
+    key,
     params,
     options
   );

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

@@ -1,6 +1,6 @@
 import type { RpcMethodParameters, Order } from '@scayle/storefront-core';
 import type { AsyncDataOptions } from 'nuxt/app';
-import type { RpcOptions, ExtendedAsyncData, KeysOf } from '../core/useRpc.js';
+import type { ExtendedAsyncData, KeysOf } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
 type ItemsType = Exclude<Order['items'], undefined>;
 type NewItemsType<P, V> = Exclude<ItemsType[number], 'product' | 'variant'> & {
@@ -13,13 +13,11 @@ export declare function useOrderConfirmation<P = {
     [k: string]: unknown;
 }, DataT = Order & {
     items?: NewItemsType<P, V>[];
-}, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key }?: {
+}, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options }?: {
     params?: MaybeRefOrGetter<RpcMethodParameters<'getOrderDataByCbd'>>;
-    options?: RpcOptions & AsyncDataOptions<Order & {
+    options?: AsyncDataOptions<Order & {
         items?: NewItemsType<P, V>[];
     }, DataT, PickKeys, DefaultT>;
-    /** @deprecated use the second argument of the composable to define the key */
-    key?: string;
 }, key?: string): ExtendedAsyncData<Order & {
     items?: NewItemsType<P, V>[];
 }, unknown, DataT, PickKeys, DefaultT>;

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

@@ -1,8 +1,8 @@
 import { useRpc } from "../core/useRpc.js";
-export function useOrderConfirmation({ params, options, key: _key } = {}, key) {
+export function useOrderConfirmation({ params, options } = {}, key = "useOrderConfirmation") {
   return useRpc(
     "getOrderDataByCbd",
-    _key ?? key ?? "useOrderConfirmation",
+    key,
     params,
     options
   );

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

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

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

@@ -1,12 +1,11 @@
 import { useRpc } from "../core/useRpc.js";
 export function useProduct({
   params,
-  options,
-  key: _key
-} = {}, key) {
+  options
+} = {}, key = "useProduct") {
   return useRpc(
     "getProductById",
-    _key ?? key ?? "useProduct",
+    key,
     params,
     options
   );

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

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

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

@@ -1,12 +1,11 @@
 import { useRpc } from "../core/useRpc.js";
 export function useProducts({
   params,
-  options,
-  key: _key
-} = {}, key) {
+  options
+} = {}, key = "useProducts") {
   return useRpc(
     "getProductsByCategory",
-    _key ?? key ?? "useProducts",
+    key,
     params,
     options
   );

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

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

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

@@ -1,12 +1,11 @@
 import { useRpc } from "../core/useRpc.js";
 export function useProductsByIds({
   params,
-  options,
-  key: _key
-} = {}, key) {
+  options
+} = {}, key = "useProductsByIds") {
   return useRpc(
     "getProductsByIds",
-    _key ?? key ?? "useProductsByIds",
+    key,
     params,
     options
   );

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

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

package/dist/runtime/composables/storefront/useProductsByReferenceKeys.js

@@ -1,12 +1,11 @@
 import { useRpc } from "../core/useRpc.js";
 export function useProductsByReferenceKeys({
   params,
-  options,
-  key: _key
-} = {}, key) {
+  options
+} = {}, key = "useProductsByReferenceKeys") {
   return useRpc(
     "getProductsByReferenceKeys",
-    _key ?? key ?? "useProductsByReferenceKeys",
+    key,
     params,
     options
   );

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

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

package/dist/runtime/composables/storefront/useProductsCount.js

@@ -1,12 +1,11 @@
 import { useRpc } from "../core/useRpc.js";
 export function useProductsCount({
   params,
-  options,
-  key: _key
-} = {}, key) {
+  options
+} = {}, key = "useProductsCount") {
   return useRpc(
     "getProductsCount",
-    _key ?? key ?? "useProductsCount",
+    key,
     params,
     options
   );

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

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

package/dist/runtime/composables/storefront/usePromotions.js

@@ -1,12 +1,11 @@
 import { useRpc } from "../core/useRpc.js";
 export function usePromotions({
   params,
-  options,
-  key: _key
-} = {}, key) {
+  options
+} = {}, key = "usePromotions") {
   return useRpc(
     "getPromotions",
-    _key ?? key ?? "usePromotions",
+    key,
     params,
     options
   );

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

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

package/dist/runtime/composables/storefront/usePromotionsByIds.js

@@ -1,12 +1,11 @@
 import { useRpc } from "../core/useRpc.js";
 export function usePromotionsByIds({
   params,
-  options,
-  key: _key
-} = {}, key) {
+  options
+} = {}, key = "usePromotionsByIds") {
   return useRpc(
     "getPromotionsByIds",
-    _key ?? key ?? "usePromotionsByIds",
+    key,
     params,
     options
   );

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

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

package/dist/runtime/composables/storefront/useShopConfiguration.js

@@ -1,11 +1,10 @@
 import { useRpc } from "../core/useRpc.js";
 export function useShopConfiguration({
-  options,
-  key: _key
-} = {}, key) {
+  options
+} = {}, key = "useShopConfiguration") {
   return useRpc(
     "getShopConfiguration",
-    _key ?? key ?? "useShopConfiguration",
+    key,
     void 0,
     options
   );

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

@@ -1,5 +1,6 @@
 import type { SearchV2SuggestionsEndpointResponseData, SearchV2With } from '@scayle/storefront-core';
-import type { Ref } from '#imports';
+import type { Status } from '../core/useRpc.js';
+import type { Ref } from 'vue';
 export type SearchOptions = Partial<{
     params: Partial<{
         categoryId: number;
@@ -7,9 +8,10 @@ export type SearchOptions = Partial<{
     }>;
     key: string;
 }>;
-export declare function useStorefrontSearch(searchQuery: Ref<string>, { params, key }?: SearchOptions): {
+export declare function useStorefrontSearch(searchQuery: Ref<string>, { params }?: SearchOptions, key?: string): {
     data: Ref<SearchV2SuggestionsEndpointResponseData | undefined, SearchV2SuggestionsEndpointResponseData | undefined>;
-    pending: Ref<boolean, boolean>;
+    status: Ref<Status, Status>;
+    error: Ref<unknown, unknown>;
     resetSearch: () => void;
     getSearchSuggestions: () => Promise<void>;
     resolveSearch: () => Promise<import("@scayle/storefront-api").SearchEntity | null | undefined>;

package/dist/runtime/composables/storefront/useStorefrontSearch.js

@@ -1,20 +1,18 @@
 import { useState } from "nuxt/app";
 import { useRpcCall } from "../core/useRpcCall.js";
-export function useStorefrontSearch(searchQuery, { params, key = "search" } = {}) {
+export function useStorefrontSearch(searchQuery, { params } = {}, key = "search") {
   const data = useState(
     `${key}-data`,
     () => void 0
   );
   const getSearchSuggestionsRpc = useRpcCall("getSearchSuggestions");
   const resolveSearchRpc = useRpcCall("resolveSearch");
-  const pending = useState(`${key}-pending`, () => false);
   const error = useState(
     `${key}-error`,
     () => void 0
   );
   const status = useState(`${key}-error`, () => "idle");
   const getSearchSuggestions = async () => {
-    pending.value = true;
     status.value = "pending";
     if (!searchQuery.value) {
       return;
@@ -27,7 +25,6 @@ export function useStorefrontSearch(searchQuery, { params, key = "search" } = {}
     } catch (e) {
       error.value = e;
     } finally {
-      pending.value = false;
       status.value = error.value ? "error" : "success";
     }
   };
@@ -46,7 +43,8 @@ export function useStorefrontSearch(searchQuery, { params, key = "search" } = {}
   };
   return {
     data,
-    pending,
+    status,
+    error,
     resetSearch,
     getSearchSuggestions,
     resolveSearch

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

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

package/dist/runtime/composables/storefront/useUserAddresses.js

@@ -1,11 +1,10 @@
 import { useRpc } from "../core/useRpc.js";
 export function useUserAddresses({
-  options,
-  key: _key
-} = {}, key) {
+  options
+} = {}, key = "useUserAddresses") {
   return useRpc(
     "getShopUserAddresses",
-    _key ?? key ?? "useUserAddresses",
+    key,
     void 0,
     options
   );

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

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

package/dist/runtime/composables/storefront/useVariant.js

@@ -1,12 +1,11 @@
 import { useRpc } from "../core/useRpc.js";
 export function useVariant({
   params,
-  options,
-  key: _key
-} = {}, key) {
+  options
+} = {}, key = "useVariant") {
   return useRpc(
     "getVariantById",
-    _key ?? key ?? "useVariant",
+    key,
     params,
     options
   );

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

@@ -1,9 +1,8 @@
 import type { Product, WishlistItem, RpcMethodParameters } from '@scayle/storefront-core';
 import { type UseRpcReturn } from '../core/useRpc.js';
-import type { MaybeRefOrGetter, ComputedRef } from '#imports';
+import { type MaybeRefOrGetter, type ComputedRef } from 'vue';
 type Options = Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getWishlist'>>;
-    key: string;
 }>;
 type UseWishlistBaseReturn = Awaited<UseRpcReturn<'getWishlist'>> & {
     addItem: (item: {
@@ -40,5 +39,5 @@ type UseWishlistBaseReturn = Awaited<UseRpcReturn<'getWishlist'>> & {
     items: ComputedRef<WishlistItem[] | undefined>;
     products: ComputedRef<Product[]>;
 };
-export declare function useWishlist({ params, key, }?: Options): UseWishlistBaseReturn & Promise<UseWishlistBaseReturn>;
+export declare function useWishlist({ params, }?: Options, key?: string): UseWishlistBaseReturn & Promise<UseWishlistBaseReturn>;
 export {};

package/dist/runtime/composables/storefront/useWishlist.js

@@ -1,18 +1,15 @@
-import {
-  BaseError,
-  HttpStatusMessage,
-  HttpStatusCode
-} from "@scayle/storefront-core";
 import { useNuxtApp } from "nuxt/app";
-import { computed } from "vue";
 import { useRpc } from "../core/useRpc.js";
 import { extendPromise } from "../../utils/promise.js";
-import { toValue, toRef } from "#imports";
+import {
+  computed,
+  toValue,
+  toRef
+} from "vue";
 import { useRpcCall } from "../core/useRpcCall.js";
 export function useWishlist({
-  params,
-  key = "useWishlist"
-} = {}) {
+  params
+} = {}, key = "useWishlist") {
   const nuxtApp = useNuxtApp();
   const addItemToWishlistRpc = useRpcCall("addItemToWishlist");
   const removeItemFromWishlistRpc = useRpcCall("removeItemFromWishlist");
@@ -33,10 +30,9 @@ export function useWishlist({
   );
   const {
     data,
-    pending: fetching,
     error,
-    refresh: fetch,
-    status
+    status,
+    refresh
   } = asyncData;
   const addItem = async (item) => {
     data.value = await addItemToWishlistRpc({
@@ -47,9 +43,7 @@ export function useWishlist({
   const removeItem = async (item) => {
     const element = findItem(item);
     if (!element) {
-      throw new BaseError(
-        HttpStatusMessage.NOT_FOUND,
-        HttpStatusCode.NOT_FOUND,
+      throw new Error(
         "Could not find wishlist item."
       );
     }
@@ -61,9 +55,7 @@ export function useWishlist({
   const replaceItem = async (item, newItem) => {
     const element = findItem(item);
     if (!element) {
-      throw new BaseError(
-        HttpStatusMessage.NOT_FOUND,
-        HttpStatusCode.NOT_FOUND,
+      throw new Error(
         `Could not find wishlist item by: ${JSON.stringify(item)}`
       );
     }
@@ -108,8 +100,7 @@ export function useWishlist({
     removeItem,
     replaceItem,
     clear,
-    fetching,
-    fetch,
+    refresh,
     toggleItem,
     findItem,
     contains,