@scayle/storefront-nuxt 7.95.4 → 8.0.0

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

@@ -1,6 +1,5 @@
 import { useRpc } from "../core/useRpc.js";
 import { extendPromise } from "../../utils/promise.js";
-import { useRpcCall } from "../core/useRpcCall.js";
 export function useIDP(params = {}, key) {
   const useRpcPromise = useRpc(
     "getExternalIdpRedirect",
@@ -9,21 +8,15 @@ export function useIDP(params = {}, key) {
   );
   const {
     data,
-    fetch,
-    fetching,
     error,
     refresh,
     status
   } = useRpcPromise;
-  const handleIDPLoginCallback = useRpcCall("handleIDPLoginCallback");
   return extendPromise(useRpcPromise.then(() => ({})), {
     data,
     fetch,
-    fetching,
     error,
     refresh,
-    status,
-    // TODO: [Next Major Release] Deprecate the property here and remove it with the next major release
-    handleIDPLoginCallback
+    status
   });
 }

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

@@ -1,19 +1,10 @@
 import type { RpcContext, RpcMethodName, RpcMethodParameters, RpcMethodReturnType } from '@scayle/storefront-core';
-import type { AsyncDataOptions } from 'nuxt/app';
-import { useAsyncData } from 'nuxt/app';
-import type { MaybeRefOrGetter } from '#imports';
+import { type AsyncDataOptions, useAsyncData } from 'nuxt/app';
+import { type MaybeRefOrGetter } from 'vue';
 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;
-};
 /** 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, ResponseT = NormalizedRpcResponse<N>> = RpcOptions & AsyncDataOptions<ResponseT, DataT, PickKeys, DefaultT>;
+export type UseRpcOptions<N extends RpcMethodName, DataT = NormalizedRpcResponse<N>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null, ResponseT = NormalizedRpcResponse<N>> = AsyncDataOptions<ResponseT, DataT, PickKeys, DefaultT>;
 /**
  * The return type of a composable based on useRpc
  */
@@ -21,11 +12,7 @@ export type UseRpcReturn<N extends RpcMethodName, DataT = NormalizedRpcResponse<
 export type Status = 'idle' | 'pending' | 'success' | 'error';
 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<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>>;
+export type ExtendedAsyncData<ResT, ErrorT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null> = AwaitedAsyncData<ResT, ErrorT, DataT, PickKeys, DefaultT> & Promise<AwaitedAsyncData<ResT, ErrorT, DataT, PickKeys, DefaultT>>;
 /**
  * `useRpc` is a wrapper around `useAsyncData` for registered RPC methods
  *

package/dist/runtime/composables/core/useRpc.js

@@ -1,9 +1,11 @@
 import { unwrap } from "@scayle/storefront-core/dist/utils/response";
-import { useNuxtApp, useAsyncData } from "nuxt/app";
+import {
+  useNuxtApp,
+  useAsyncData
+} from "nuxt/app";
 import { useCoreLog } from "../useCoreLog.js";
 import { useCurrentShop } from "./useCurrentShop.js";
-import { extendPromise } from "../../utils/promise.js";
-import { toValue, computed, isRef } from "#imports";
+import { toValue, isRef } from "vue";
 import { useRuntimeConfig } from "#app/nuxt";
 function getFetch(nuxtApp, log) {
   const fetch = nuxtApp.ssrContext?.event.$fetch ?? $fetch;
@@ -16,15 +18,9 @@ export function useRpc(method, key, params, options) {
   const currentShop = useCurrentShop();
   const log = useCoreLog("rpc");
   const nuxtApp = useNuxtApp();
-  const { public: { storefront: { disableDefaultGetCachedDataOverride } } } = useRuntimeConfig();
-  if (options && options.autoFetch !== void 0) {
-    log.warn("autoFetch is disabled; use immediate instead");
-    if (options.immediate === void 0) {
-      options.immediate = options.autoFetch;
-    } else {
-      log.warn("autoFetch will be ignored because immediate was specified");
-    }
-  }
+  const {
+    public: { storefront }
+  } = useRuntimeConfig();
   const asyncData = useAsyncData(
     key,
     async () => {
@@ -47,17 +43,12 @@ export function useRpc(method, key, params, options) {
     {
       // Both refs and getter functions are valid watch sources
       ...isRef(params) || typeof params === "function" ? { watch: [params] } : {},
-      getCachedData: disableDefaultGetCachedDataOverride ? void 0 : (key2, nuxtApp2) => {
+      getCachedData: storefront.legacy?.enableDefaultGetCachedDataOverride ? (key2, nuxtApp2) => {
         const hydrationData = nuxtApp2.isHydrating ? nuxtApp2.payload.data[key2] : nuxtApp2.static.data[key2];
         return hydrationData ?? nuxtApp2._asyncData[key2]?.data.value;
-      },
+      } : void 0,
       ...options
     }
   );
-  return extendPromise(asyncData, {
-    /** @deprecated - use refresh instead */
-    fetch: asyncData.refresh,
-    /** @deprecated - use `status.value === 'pending'´ instead */
-    fetching: computed(() => asyncData.status.value === "pending")
-  });
+  return asyncData;
 }

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

@@ -20,7 +20,7 @@ export declare function useSession(): {
         success: false;
     }>;
     resetPasswordByHash: (params: import("utility-types").Optional<import("@scayle/storefront-core").UpdatePasswordByHashRequest, "shop_id">) => Promise<never>;
-    loginWithIDP: (params: string | {
+    loginWithIDP: (params: {
         code: string;
     }) => Promise<{
         message: string;

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

@@ -1,14 +1,12 @@
 import type { ShopUser, UpdatePasswordParams } from '@scayle/storefront-core';
 import { type UseRpcReturn } from './useRpc.js';
-import { type ComputedRef } from '#imports';
+import { type ComputedRef } from 'vue';
 export type ExtendedUseUserParams = {
     key?: string;
-    /** @deprecated use immediate instead */
-    autoFetch?: boolean;
     immediate?: boolean;
     lazy?: boolean;
 };
-type UseUserBaseReturn = Pick<Awaited<UseRpcReturn<'getUser'>>, 'error' | 'status' | 'fetch' | 'fetching'> & {
+type UseUserBaseReturn = Pick<Awaited<UseRpcReturn<'getUser'>>, 'error' | 'status' | 'refresh'> & {
     updateUser: (payload: Partial<ShopUser>) => Promise<void>;
     updatePassword: (payload: UpdatePasswordParams) => Promise<void>;
     user: ComputedRef<ShopUser | undefined>;

package/dist/runtime/composables/core/useUser.js

@@ -1,9 +1,8 @@
 import { useNuxtApp } from "nuxt/app";
-import { computed } from "vue";
 import { useCoreLog } from "../useCoreLog.js";
 import { extendPromise } from "../../utils/promise.js";
 import { useRpc } from "./useRpc.js";
-import { toValue } from "#imports";
+import { toValue, computed } from "vue";
 import { useRpcCall } from "../core/useRpcCall.js";
 export function useUser(options = {}) {
   const nuxtApp = useNuxtApp();
@@ -11,14 +10,6 @@ export function useUser(options = {}) {
   const updateUserRpc = useRpcCall("updateShopUser");
   const updatePasswordRpc = useRpcCall("updatePassword");
   const refreshUserRpc = useRpcCall("refreshUser");
-  if (options && options.autoFetch !== void 0) {
-    log.warn("autoFetch is disabled; use immediate instead");
-    if (options.immediate === void 0) {
-      options.immediate = options.autoFetch;
-    } else {
-      log.warn("autoFetch will be ignored because immediate was specified");
-    }
-  }
   const {
     immediate = true,
     lazy = false,
@@ -38,7 +29,7 @@ export function useUser(options = {}) {
       }
     }
   );
-  const { data, fetching, fetch, error, status } = asyncDataPromise;
+  const { data, refresh, error, status } = asyncDataPromise;
   const updateUser = async (payload) => {
     log.debug("Update user");
     data.value = await updateUserRpc(payload);
@@ -66,7 +57,7 @@ export function useUser(options = {}) {
     user,
     isLoggedIn,
     customerType,
-    fetching,
+    refresh,
     fetch,
     forceRefresh,
     updateUser,

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

@@ -14,7 +14,6 @@ export * from './storefront/useCategories.js';
 export * from './storefront/useCategoryById.js';
 export * from './storefront/useCategoryByPath.js';
 export * from './storefront/useCurrentPromotions.js';
-export * from './storefront/useFacet.js';
 export * from './storefront/useFilters.js';
 export * from './storefront/useNavigationTree.js';
 export * from './storefront/useNavigationTrees.js';
@@ -27,8 +26,6 @@ export * from './storefront/useProductsByReferenceKeys.js';
 export * from './storefront/useProductsCount.js';
 export * from './storefront/usePromotions.js';
 export * from './storefront/usePromotionsByIds.js';
-export * from './storefront/useQueryFilterState.js';
-export * from './storefront/useSearch.js';
 export * from './storefront/useShopConfiguration.js';
 export * from './storefront/useStorefrontSearch.js';
 export * from './storefront/useUserAddresses.js';

package/dist/runtime/composables/index.js

@@ -14,7 +14,6 @@ export * from "./storefront/useCategories.js";
 export * from "./storefront/useCategoryById.js";
 export * from "./storefront/useCategoryByPath.js";
 export * from "./storefront/useCurrentPromotions.js";
-export * from "./storefront/useFacet.js";
 export * from "./storefront/useFilters.js";
 export * from "./storefront/useNavigationTree.js";
 export * from "./storefront/useNavigationTrees.js";
@@ -27,8 +26,6 @@ export * from "./storefront/useProductsByReferenceKeys.js";
 export * from "./storefront/useProductsCount.js";
 export * from "./storefront/usePromotions.js";
 export * from "./storefront/usePromotionsByIds.js";
-export * from "./storefront/useQueryFilterState.js";
-export * from "./storefront/useSearch.js";
 export * from "./storefront/useShopConfiguration.js";
 export * from "./storefront/useStorefrontSearch.js";
 export * from "./storefront/useUserAddresses.js";

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

@@ -1,13 +1,15 @@
 import type { AddOrUpdateItemType, RpcMethodParameters, RpcMethodReturnType, BasketItem, Product, BasketTotalPrice } from '@scayle/storefront-core';
 import { ExistingItemHandling } from '@scayle/storefront-core';
-import { type UseRpcReturn } from '../core/useRpc.js';
-import { type MaybeRefOrGetter, type ComputedRef } from '#imports';
+import { type NormalizedRpcResponse, type UseRpcReturn } from '../core/useRpc.js';
+import { type MaybeRefOrGetter, type ComputedRef, type Ref } from 'vue';
 import type { BasketKey, BasketPackageInformation } from '@scayle/storefront-api';
 type UseBasketOptions = Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getBasket'>>;
     key: string;
 }>;
-type UseBasketBaseReturn = Awaited<UseRpcReturn<'getBasket'>> & {
+type UseBasketBaseReturn = Omit<Awaited<UseRpcReturn<'getBasket'>>, 'data'> & {
+    data: Ref<NormalizedRpcResponse<'getBasket'>['basket'] | null>;
+} & {
     addItem: (item: AddOrUpdateItemType & {
         existingItemHandling?: ExistingItemHandling;
     }) => Promise<void>;
@@ -41,5 +43,5 @@ type UseBasketBaseReturn = Awaited<UseRpcReturn<'getBasket'>> & {
     packages: ComputedRef<BasketPackageInformation[] | undefined>;
     shippingDates: ComputedRef<(string | null)[] | undefined>;
 };
-export declare function useBasket({ params, key, }?: UseBasketOptions): UseBasketBaseReturn & Promise<UseBasketBaseReturn>;
+export declare function useBasket({ params, }?: UseBasketOptions, key?: string): UseBasketBaseReturn & Promise<UseBasketBaseReturn>;
 export {};

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

@@ -1,25 +1,26 @@
 import { generateBasketKey } from "@scayle/storefront-core/dist/utils/keys";
 import {
-  BaseError,
+  AddToBasketFailureKind,
   ExistingItemHandling,
-  getShippingDates,
-  HttpStatusCode,
-  HttpStatusMessage
+  getShippingDates
 } from "@scayle/storefront-core";
-import { useNuxtApp } from "nuxt/app";
-import { computed } from "vue";
+import {
+  wasAddedWithReducedQuantity
+} from "@scayle/storefront-core/dist/utils/basket";
 import { extendPromise } from "../../utils/promise.js";
-import { useRpc } from "../core/useRpc.js";
+import {
+  useRpc
+} from "../core/useRpc.js";
 import { useRpcCall } from "../core/useRpcCall.js";
 import {
   toValue,
-  toRef
-} from "#imports";
+  toRef,
+  computed
+} from "vue";
+import { FetchError } from "ofetch";
 export function useBasket({
-  params,
-  key = "useBasket"
-} = {}) {
-  const nuxtApp = useNuxtApp();
+  params
+} = {}, key = "useBasket") {
   const addItemToBasketRpc = useRpcCall("addItemToBasket");
   const addItemsToBasketRpc = useRpcCall("addItemsToBasket");
   const mergeBasketsRpc = useRpcCall("mergeBaskets");
@@ -30,13 +31,13 @@ export function useBasket({
     // NOTE: In some cases it might be ok to fetch on server
     watch: [toRef(params)],
     dedupe: "defer",
-    getCachedData: (key2) => {
+    transform: (basketResponse) => basketResponse.basket,
+    getCachedData: (key2, nuxtApp) => {
       return toValue(nuxtApp._asyncData[key2]?.data) ?? void 0;
     }
   });
   const {
     data,
-    pending,
     error,
     refresh,
     status
@@ -50,24 +51,56 @@ export function useBasket({
     customData,
     itemGroup
   }) => {
-    data.value = await addItemToBasketRpc({
-      promotionId,
-      variantId,
-      quantity,
-      existingItemHandling,
-      displayData,
-      customData,
-      itemGroup,
-      with: toValue(params)
-    });
+    try {
+      const { basket, errors: basketErrors } = await addItemToBasketRpc({
+        promotionId,
+        variantId,
+        quantity,
+        existingItemHandling,
+        displayData,
+        customData,
+        itemGroup,
+        with: toValue(params)
+      });
+      data.value = basket;
+      handleBasketError(basketErrors);
+    } catch (error2) {
+      handleFetchError(error2);
+    }
   };
   const addItems = async (items2, existingItemHandling = ExistingItemHandling.AddQuantityToExisting) => {
-    data.value = await addItemsToBasketRpc({
-      items: items2,
-      existingItemHandling,
-      with: toValue(params)
-    });
+    try {
+      const { basket, errors: basketErrors } = await addItemsToBasketRpc({
+        items: items2,
+        existingItemHandling,
+        with: toValue(params)
+      });
+      data.value = basket;
+      handleBasketError(basketErrors);
+    } catch (error2) {
+      handleFetchError(error2);
+    }
+  };
+  const handleBasketError = (basketErrors) => {
+    if (wasAddedWithReducedQuantity(basketErrors)) {
+      throw new Error("Item was added with reduced quantity", {
+        cause: AddToBasketFailureKind.ItemAddedWithReducedQuantity
+      });
+    }
+  };
+  const handleFetchError = (error2) => {
+    if (error2 instanceof FetchError && isAddOrUpdateItemError(
+      error2.data.errors?.[0]
+    ) && error2.data.errors?.[0].operation !== "delete") {
+      throw new Error(error2.message, {
+        cause: error2.data.errors?.[0].kind
+      });
+    }
+    throw error2;
   };
+  function isAddOrUpdateItemError(error2) {
+    return typeof error2 === "object" && error2 !== null && "operation" in error2 && "kind" in error2;
+  }
   const mergeBaskets = async (args) => {
     return await mergeBasketsRpc({
       ...args,
@@ -88,22 +121,22 @@ export function useBasket({
   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 basket item by variant-id: ${item.variantId}`
       );
     }
-    data.value = await removeItemFromBasketRpc({
+    const { basket } = await removeItemFromBasketRpc({
       itemKey: element.key,
       with: toValue(params)
     });
+    data.value = basket;
   };
   const removeItemByKey = async (itemKey) => {
-    data.value = await removeItemFromBasketRpc({
+    const { basket } = await removeItemFromBasketRpc({
       itemKey,
       with: toValue(params)
     });
+    data.value = basket;
   };
   const clear = async () => {
     await clearBasketRpc();
@@ -163,9 +196,6 @@ export function useBasket({
     packages,
     shippingDates,
     isEmpty,
-    fetching: pending,
-    pending,
-    fetch: refresh,
     refresh,
     count,
     countWithoutSoldOutItems,

package/dist/runtime/composables/storefront/useBrand.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 useBrand<DataT = NormalizedRpcResponse<'getBrandById'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
+import type { MaybeRefOrGetter } from 'vue';
+export declare function useBrand<DataT = NormalizedRpcResponse<'getBrandById'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getBrandById'>>;
     options: UseRpcOptions<'getBrandById', DataT, PickKeys, DefaultT>;
-    /** @deprecated use the second argument of the composable to define the key */
-    key: string;
 }>, key?: string): UseRpcReturn<'getBrandById', DataT, PickKeys, DefaultT>;

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

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

package/dist/runtime/composables/storefront/useBrands.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 useBrands<DataT = NormalizedRpcResponse<'getBrands'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
+import type { MaybeRefOrGetter } from 'vue';
+export declare function useBrands<DataT = NormalizedRpcResponse<'getBrands'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getBrands'>>;
     options: UseRpcOptions<'getBrands', DataT, PickKeys, DefaultT>;
-    /** @deprecated use the second argument of the composable to define the key */
-    key: string;
 }>, key?: string): UseRpcReturn<'getBrands', DataT, PickKeys, DefaultT>;

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

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

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

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

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

@@ -3,12 +3,11 @@ import { extendPromise } from "../../utils/promise.js";
 import { useRpcCall } from "../core/useRpcCall.js";
 export function useCategories({
   params,
-  options,
-  key: _key
-} = {}, key) {
+  options
+} = {}, key = "useCategories") {
   const useRpcPromise = useRpc(
     "getCategoriesByPath",
-    _key ?? key ?? "useCategories",
+    key,
     params,
     options
   );
@@ -17,16 +16,12 @@ export function useCategories({
     data,
     error,
     status,
-    fetch,
-    fetching,
     refresh
   } = useRpcPromise;
   return extendPromise(useRpcPromise.then(() => ({})), {
     data,
     error,
     status,
-    fetch,
-    fetching,
     refresh,
     getCategoryById: (id, includeHidden) => getCategoryById({ id, includeHidden })
   });

package/dist/runtime/composables/storefront/useCategoryById.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 useCategoryById<DataT = NormalizedRpcResponse<'getCategoryById'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
+import type { MaybeRefOrGetter } from 'vue';
+export declare function useCategoryById<DataT = NormalizedRpcResponse<'getCategoryById'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getCategoryById'>>;
     options: UseRpcOptions<'getCategoryById', DataT, PickKeys, DefaultT>;
-    /** @deprecated use the second argument of the composable to define the key */
-    key: string;
 }>, key?: string): UseRpcReturn<'getCategoryById', DataT, PickKeys, DefaultT>;

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

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

package/dist/runtime/composables/storefront/useCategoryByPath.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 useCategoryByPath<DataT = NormalizedRpcResponse<'getCategoryByPath'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }: {
+import type { MaybeRefOrGetter } from 'vue';
+export declare function useCategoryByPath<DataT = NormalizedRpcResponse<'getCategoryByPath'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, }: {
     params: MaybeRefOrGetter<RpcMethodParameters<'getCategoryByPath'>>;
     options?: UseRpcOptions<'getCategoryByPath', DataT, PickKeys, DefaultT>;
-    /** @deprecated use the second argument of the composable to define the key */
-    key: string;
 }, key?: string): UseRpcReturn<'getCategoryByPath', DataT, PickKeys, DefaultT>;

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

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

package/dist/runtime/composables/storefront/useCurrentPromotions.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 useCurrentPromotions<DataT = NormalizedRpcResponse<'getCurrentPromotions'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
+import type { MaybeRefOrGetter } from 'vue';
+export declare function useCurrentPromotions<DataT = NormalizedRpcResponse<'getCurrentPromotions'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getCurrentPromotions'>>;
     options: UseRpcOptions<'getCurrentPromotions', DataT, PickKeys, DefaultT>;
-    /** @deprecated use the second argument of the composable to define the key */
-    key: string;
 }>, key?: string): UseRpcReturn<'getCurrentPromotions', DataT, PickKeys, DefaultT>;

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

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

package/dist/runtime/composables/storefront/useFilters.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 useFilters<DataT = NormalizedRpcResponse<'getFilters'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
+import type { MaybeRefOrGetter } from 'vue';
+export declare function useFilters<DataT = NormalizedRpcResponse<'getFilters'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getFilters'>>;
     options: UseRpcOptions<'getFilters', DataT, PickKeys, DefaultT>;
-    /** @deprecated use the second argument of the composable to define the key */
-    key: string;
 }>, key?: string): UseRpcReturn<'getFilters', DataT, PickKeys, DefaultT>;