@scayle/storefront-nuxt 8.10.4 → 8.11.1

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @scayle/storefront-nuxt
 
+## 8.11.1
+
+### Patch Changes
+
+**Dependencies**
+
+- Updated dependency to @scayle/storefront-core@8.10.0
+
+## 8.11.0
+
+### Minor Changes
+
+- Include `rpcCall` when building the context. This utility function can be used within RPC methods to invoke another RPC method.
+
+### Patch Changes
+
+**Dependencies**
+
+- Updated dependency to @scayle/unstorage-compression-driver@0.2.4
+- Updated dependency to @scayle/storefront-core@8.9.0
+
 ## 8.10.4
 
 ### Patch Changes

package/dist/module.json

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

package/dist/module.mjs

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

package/dist/runtime/api/cacheAuth.d.ts

@@ -1,12 +1,27 @@
 import type { EventHandler } from 'h3';
 /**
- * Wrap an event handler protected by the authentication specified in `cache.auth`
- * @param handler
+ * Wraps an event handler with cache authentication.
+ *
+ * It takes an event handler and returns a new handler that is protected by
+ * basic authentication if cache authentication is configured in the runtime config (`cache.auth`).
+ * If cache authentication is not configured, the original handler is returned.
+ *
+ * @param handler The event handler to wrap.
+ *
+ * @returns The wrapped event handler.
  */
 export declare const eventHandlerWithCacheAuth: (handler: EventHandler) => EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
 /**
- * Wrap an event handler with basic auth
- * @param handler
- * @param auth
+ * Wraps an event handler with basic authentication.
+ *
+ * This function enhances a given event handler with basic authentication functionality.
+ * It checks for an Authorization header in the request and compares the decoded
+ * credentials with the provided authentication string. If the credentials match,
+ * the original handler is executed.
+ *
+ * @param handler The event handler to be wrapped.
+ * @param auth The authentication string in the format 'username:password'.
+ *
+ * @returns The wrapped and awaited event handler, else an authentication failure response is returned.
  */
 export declare const eventHandlerWithBasicAuth: (handler: EventHandler, auth: string) => EventHandler<import("h3").EventHandlerRequest, Promise<any>>;

package/dist/runtime/api/purgeAll.d.ts

@@ -1,2 +1,14 @@
+/**
+ * Purges the entire cache.
+ *
+ * This event handler purges all entries from the configured cache.
+ * It requires both `$rpcContext` and `$cache` to be present in the event context.
+ * If either is missing, it returns a 500 Internal Server Error.
+ * If the purge operation is successful, it returns a 200 OK with `{ success: true }`.
+ * If an error occurs during purging, it returns a 500 Internal Server Error with `{ success: false }`
+ * and logs the error using the logger provided by `$rpcContext`.
+ *
+ * @returns A promise that resolves to either an object indicating success or a `Response` object indicating an error.
+ */
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
 export default _default;

package/dist/runtime/api/purgeTags.d.ts

@@ -1,2 +1,16 @@
+/**
+ * Purges cache entries by tags.
+ *
+ * This event handler purges cache entries associated with the provided tags.
+ * It requires both `$rpcContext` and `$cache` to be present in the event context.
+ * If either is missing, it returns a 500 Internal Server Error.
+ * It reads an array of tags from the request body.
+ * If the body is empty or no tags are provided, it returns a 400 Bad Request.
+ * If the purge operation is successful, it returns 200 OK with `{ success: true }`.
+ * If an error occurs during the purge, it returns a 500 Internal Server Error with `{ success: false }`
+ * and logs the error using the logger provided by the `$rpcContext`.
+ *
+ * @returns A promise resolving to an object indicating success or a `Response` object with an error status.
+ */
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
 export default _default;

package/dist/runtime/api/rpcHandler.d.ts

@@ -1,21 +1,19 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string | true | string[] | import("@scayle/storefront-core").ShopUser | Response | import("@scayle/storefront-api").Product | import("@scayle/storefront-api").Product[] | {
-    count: number;
-} | {
-    filters: import("@scayle/storefront-api").FiltersEndpointResponseData;
-    unfilteredCount: number;
-} | {
-    products: import("@scayle/storefront-api").Product[];
-    pagination: {
-        current: number;
-        total: number;
-        perPage: number;
-        page: number;
-        first: number;
-        prev: number;
-        next: number;
-        last: number;
-    };
-} | {
+/**
+ * Generic event handler for RPC methods.
+ *
+ * It retrieves the RPC method name from the request path,
+ * reads the payload from the request body.
+ * It utilizes hooks provided by Nitro to allow for custom logic before,
+ * after, and in case of errors during RPC calls.
+ *
+ * @param event The H3 event object.
+ *
+ * @returns The result of the RPC call or a `Response` object with an error status.
+ */
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string | true | string[] | import("@scayle/storefront-core").ShopUser | Response | import("@scayle/storefront-api").Product | import("@scayle/storefront-api").Product[] | import("@scayle/storefront-core").FetchProductsCountResponse | import("@scayle/storefront-core").FetchFiltersResponse | import("@scayle/storefront-core").FetchProductsByCategoryResponse | import("@scayle/storefront-api").Wishlist | {
+    accessToken: string;
+    checkoutJwt: string;
+} | import("@scayle/storefront-api").VariantDetail[] | {
     basket: import("@scayle/storefront-api").BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>;
 } | {
     readonly type: "success";
@@ -32,10 +30,7 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
     activeNode: import("@scayle/storefront-api").Category;
 } | import("@scayle/storefront-core").Order | import("@scayle/storefront-api").SearchV2SuggestionsEndpointResponseData | import("@scayle/storefront-api").SearchEntity | import("@scayle/storefront-api").ShopConfiguration | {
     user: import("@scayle/storefront-core").ShopUser | undefined;
-} | import("@scayle/storefront-api").Wishlist | import("@scayle/storefront-core").ShopUserAddress[] | {
-    accessToken: string;
-    checkoutJwt: string;
-} | import("@scayle/storefront-api").VariantDetail[] | import("@scayle/storefront-api").NavigationAllEndpointResponseData | import("@scayle/storefront-api").NavigationTree | {
+} | import("@scayle/storefront-core").ShopUserAddress[] | import("@scayle/storefront-api").NavigationAllEndpointResponseData | import("@scayle/storefront-api").NavigationTree | {
     success: true;
 } | {
     success: false;

package/dist/runtime/api/up.d.ts

@@ -1,3 +1,11 @@
+/**
+ * Health check endpoint.
+ *
+ * This simple endpoint returns a JSON object indicating that the service is up.
+ * It is typically used for monitoring and health checks.
+ *
+ * @returns An object with a status property set to 'up'.
+ */
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, {
     status: string;
 }>;

package/dist/runtime/cached.d.ts

@@ -1,2 +1,15 @@
 import { type Log, type CacheInterface } from '@scayle/storefront-core';
+/**
+ * Creates and returns a bound cached function.
+ *
+ * It initializes a new `Cached` instance with provided parameters and
+ * returns its `execute` method bound to the instance.
+ * This allows for easy use of the caching functionality provided by `@scayle/storefront-core`.
+ *
+ * @param $cache The cache interface instance.
+ * @param $log The logging instance.
+ * @param enabled Whether caching is enabled or not. Defaults to true if undefined.
+ *
+ * @returns A bound function that can be used to execute cached operations.
+ */
 export declare function getCachedFunction($cache: CacheInterface, $log: Log, enabled: boolean | undefined): <TArgs extends unknown[], TResult>(fn: (...args: TArgs) => Promise<TResult>, options?: import("@scayle/storefront-core").CacheOptions) => Awaited<(...args: TArgs) => Promise<TResult>>;

package/dist/runtime/campaignKey.d.ts

@@ -1,2 +1,20 @@
 import type { StorefrontAPIClient, CachedType, Log } from '@scayle/storefront-core';
+/**
+ * Fetches the key of the first active campaign.
+ *
+ * Retrieves campaigns from the Storefront API, filters for non-ended campaigns,
+ * sorts them, and returns the key of the first active one.
+ * The retrieved campaigns are cached for a specified duration.
+ *
+ * @see https://scayle.dev/en/user-guide/shops/promotions/discounts-and-offers/price-campaigns
+ * @see https://scayle.dev/en/api-guides/storefront-api/resources/campaigns/list-campaigns
+ *
+ * @param sapiClient The Storefront API client.
+ * @param cached The caching function.
+ * @param log The logging instance.
+ *
+ * @throws {Error} If fetching or processing campaigns fails.
+ *
+ * @returns The key of the first active campaign, or undefined if no active campaign is found or an error occurs.
+ */
 export declare const fetchCampaignKey: (sapiClient: StorefrontAPIClient, cached: CachedType, log: Log) => Promise<string | undefined>;

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

@@ -1,2 +1,12 @@
 import type { PublicShopConfig } from '../../../module.js';
+/**
+ * Provides a reactive list of available shops.
+ *
+ * This composable uses [`useState`](https://nuxt.com/docs/api/composables/use-state)
+ * to create a reactive state variable that holds an array of `PublicShopConfig` objects.
+ * The initial value of the state is an empty array. This state can be used to
+ * dynamically display data of the available shops within the application.
+ *
+ * @returns A reactive `ref` containing an array of available shop configurations.
+ */
 export declare function useAvailableShops(): import("vue").Ref<PublicShopConfig[], PublicShopConfig[]>;

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

@@ -1,3 +1,13 @@
 import type { Ref } from 'vue';
 import type { PublicShopConfig } from '../../../module.js';
+/**
+ * Provides a reactive reference to the current shop configuration.
+ *
+ * This composable retrieves the current shop configuration from the Nuxt app instance.
+ * It then uses [`useState`](https://nuxt.com/docs/api/composables/use-state) to
+ * create a reactive reference to this configuration, allowing components
+ * to reactively update when the current shop changes.
+ *
+ * @returns A reactive `ref` to the current shop's configuration.
+ */
 export declare const useCurrentShop: () => Ref<PublicShopConfig>;

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

@@ -1,20 +1,71 @@
+/**
+ * Representation of options for formatting currencies.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat
+ */
 type FormatCurrencyOptions = {
+    /**
+     * The locale to use for formatting.
+     */
     locale?: string;
+    /**
+     * The number of fraction digits to use for the currency.
+     */
     currencyFractionDigits?: number;
+    /**
+     * The style ('currency' or 'decimal') to use for formatting. Defaults to 'currency'.
+     */
     style?: 'currency';
+    /**
+     * The currency code (e.g., 'EUR', 'USD') to use for formatting.
+     */
     currency: string;
 } | {
+    /**
+     * The locale to use for formatting.
+     */
     locale?: string;
+    /**
+     * The number of fraction digits to use for the currency.
+     */
     currencyFractionDigits?: number;
+    /**
+     * The style to use for formatting.
+     */
     style: 'decimal';
 };
+/**
+ * Representation of options for formatting percentages.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat
+ */
+type FormatPercentageOptions = {
+    /**
+     * The locale to use for formatting.
+     */
+    locale?: string;
+    /**
+     * The minimum number of fraction digits to use.
+     */
+    minimumFractionDigits?: number;
+    /**
+     * The maximum number of fraction digits to use.
+     */
+    maximumFractionDigits?: number;
+    /**
+     * How to display the sign for the percentage.
+     */
+    signDisplay?: Intl.NumberFormatOptions['signDisplay'];
+};
+/**
+ * Provides currency and percentage formatting helpers.
+ *
+ * It leverages the current shop's locale and currency settings.
+ *
+ * @returns An object containing the formatCurrency and formatPercentage functions.
+ */
 export declare function useFormatHelpers(): {
     formatCurrency: (value: number, options?: FormatCurrencyOptions) => string;
-    formatPercentage: (value: number, options?: {
-        locale?: string;
-        minimumFractionDigits?: number;
-        maximumFractionDigits?: number;
-        signDisplay?: Intl.NumberFormatOptions["signDisplay"];
-    }) => string;
+    formatPercentage: (value: number, options?: FormatPercentageOptions) => string;
 };
 export {};

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

@@ -1,6 +1,23 @@
 import type { MaybeRefOrGetter } from 'vue';
 import type { RpcMethodParameters } from '@scayle/storefront-core';
 import { type UseRpcReturn } from '../core/useRpc.js';
+/**
+ * The shape of the data returned by the `getExternalIdpRedirect` RPC call.
+ */
 type UseIDPBaseReturn = Pick<Awaited<UseRpcReturn<'getExternalIdpRedirect'>>, 'data' | 'error' | 'status' | 'refresh'>;
+/**
+ * Retrieves an external IDP redirect URL.
+ *
+ * This composables uses the `useRpc` composable to call the `getExternalIdpRedirect` RPC method.
+ *
+ * @see https://scayle.dev/en/storefront-guide/developer-guide/basic-setup/authentication#redirect-url
+ *
+ * @param params The parameters for the `getExternalIdpRedirect` RPC call.
+ * @param key A unique key for the RPC call. Used for caching and invalidation. Defaults to 'useIDP'.
+
+ * @returns An object containing the `data` returned from, any `error` encountered within,
+            the current `status` and a function to manually `refresh` the RPC call.
+ *          It also acts as a promise that resolves to the same object.
+ */
 export declare function useIDP(params?: MaybeRefOrGetter<RpcMethodParameters<'getExternalIdpRedirect'>>, key?: string): UseIDPBaseReturn & Promise<UseIDPBaseReturn>;
 export {};

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

@@ -1,2 +1,14 @@
 import type { Log } from '@scayle/storefront-core';
+/**
+ * Retrieves a logging instance.
+ *
+ * It allows for creating a namespaced logger using the provided `subSpace` argument.
+ * If a namespace is specified, the function will return a logger scoped to that subspace.
+ * Otherwise, it returns the root logger.
+ *
+ * @param subSpace The namespace to create the logger for.
+ *
+ * @returns The log instance, a namespace is specified, a logger scoped to that subspace.
+ *          Otherwise, it returns the root logger.
+ */
 export declare function useLog(subSpace?: string): Log;

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

@@ -1,41 +1,93 @@
 import type { RpcContext, RpcMethodName, RpcMethodParameters, RpcMethodReturnType } from '@scayle/storefront-core';
 import { type AsyncDataOptions, useAsyncData } from 'nuxt/app';
 import { type MaybeRefOrGetter } from 'vue';
+/**
+ * Extracts keys from a type `T` as an array of strings.
+ *
+ * @template T The type from which to extract keys.
+ */
 export type KeysOf<T> = Array<T extends T ? (keyof T extends string ? keyof T : never) : never>;
-/** The normalized return type of an RPC */
+/**
+ * Normalized return type of a RPC method, excluding its `Response` object.
+ *
+ * @template N The RPC Method Name.
+ */
 export type NormalizedRpcResponse<N extends RpcMethodName> = Exclude<Awaited<RpcMethodReturnType<N>>, Response>;
+/**
+ * Representation of options for the `useRpc` composable, extending `AsyncDataOptions`.
+ *
+ * @template N The RPC Method Name.
+ * @template DataT The data type. Defaults to `NormalizedRpcResponse<N>`.
+ * @template PickKeys The keys to pick from `DataT`. Defaults to all keys of `DataT`.
+ * @template DefaultT  The default value type. Defaults to `null`.
+ * @template ResponseT The response type. Defaults to `NormalizedRpcResponse<N>`.
+ */
 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
+ * Return type of the `useRpc` composable, extending `ExtendedAsyncData`.
+ *
+ * @template N The RPC Method Name.
+ * @template DataT The data type. Defaults to `NormalizedRpcResponse<N>`.
+ * @template PickKeys The keys to pick from `DataT.` Defaults to all keys of `DataT`.
+ * @template DefaultT The default value type. Defaults to `null`.
+ * @template ResponseT The response type. Defaults to `NormalizedRpcResponse<N>`.
  */
 export type UseRpcReturn<N extends RpcMethodName, DataT = NormalizedRpcResponse<N>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null, ResponseT = NormalizedRpcResponse<N>> = ExtendedAsyncData<ResponseT, unknown, DataT, PickKeys, DefaultT>;
 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>>;
+/**
+ * Extended `AsyncData` type, adding a promise to the result.
+ *
+ * @template ResT The response type.
+ * @template ErrorT The error type. Defaults to `unknown`.
+ * @template DataT The data type. Defaults to `ResT`.
+ * @template PickKeys The keys to pick from `DataT`. Defaults to all keys of `DataT`.
+ * @template DefaultT The default value type. Defaults to `null`.
+ */
 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
- *
- * This is slightly different from the useRpc we have in Nuxt2
- * It is built on top of useAsyncData and matches its API more than the Nuxt2 API
- * Notably, fetch is now refresh. The fetching property remains the same.
- * It also doesn't directly use rpcCall, instead calling $fetch directly
- * The main difference regards how params are passed:
- * In Nuxt2 for an RPC with params, the params are passed when calling `fetch`.
- * In Nuxt3 for an RPC with params, the params are passed to `useRpc`.
- * Additionally, in Nuxt3 the params can be `Params`, `Ref<Params>` or `() => Params`
- *
- * @param method - the RPC method name
- * @param key - a unique key for persisting the data between server and client and de-duplicating requests
- * @param params - parameters to pass to the RPC method.
- * This can be specified in three ways: as a raw value, a `Ref` or a function that returns the params
- * - When passed as a raw value, the parameters are set at the point `useRpc` is called. Subsequent `refresh` calls will use the same params.
- * - When passed as a function, the function will be invoked each time `refresh` is called to get the params.
- * - When passed as a Ref, a watcher wil be added that calls `refresh` each time params change.
- * @param options - Override the options passed to `useAsyncData`.
- * By default, `useRpc` will set `immediate` to `false` and will pass `[params]` to `watch` if `params` is a `Ref`.
- * But anything passed here will take precedence.
- * @see {@link https://nuxt.com/docs/api/composables/use-async-data#params}
+ * `useRpc` is a wrapper around `useAsyncData` for registered RPC methods.
+ *
+ * This composable provides a declarative approach to data fetching by wrapping
+ * `useAsyncData` for registered RPC methods. It handles the fetch state,
+ * automatically executes the RPC method, and returns the result or any errors.
+ * Many Storefront composables utilize `useRpc` as lightweight wrappers around provided RPC methods.
+ *
+ * The parameters for the RPC call can be passed as a raw value, a ref, or a function.  If a reactive ref or function is provided,
+ * `useRpc` will automatically re-fetch the data when the parameters change.
+ *
+ * By default, `useRpc` utilizes a shared cache, so all instances called with the same key will share the same data.  This behavior can be
+ * disabled globally via the `disableDefaultGetCachedDataOverride` option in the public runtime config, or individually per call using the `options` parameter.
+ *
+ * @see https://nuxt.com/docs/api/composables/use-async-data#params
+ * @see https://scayle.dev/en/storefront-guide/developer-guide/basic-setup/rpc-methods#userpc
+ *
+ * @param method The name of the RPC method to call (e.g., 'useBrand).
+ * @param key A unique key for caching, persisting the data between server and client,
+ *            and de-duplicating requests (e.g., 'use-brand').
+ * @param params The parameters for the RPC method. Can be a value, a `Ref`,
+ *               or a function. If reactive, changes will trigger a re-fetch.
+ *                - When passed as a raw value, the parameters are set at the point
+ *                 `useRpc` is called. Subsequent `refresh` calls will use the same params.
+ *                - When passed as a function, the function will be invoked each
+ *                  time `refresh` is called to get the params.
+ *                - When passed as a Ref, a watcher wil be added that
+ *                  calls `refresh` each time params change.
+ * @param options Options for `useAsyncData`, including `watch`, `getCachedData`,
+ *                and more. Can be used to control caching behavior. By default,
+ *                `useRpc` will set `immediate` to `false` and will pass `[params]`
+ *                to `watch` if `params` is a `Ref`.
+ *
+ *  @returns An object containing the `data`, `status`, and other properties from
+ *           `useAsyncData`, as well as a promise that resolves to the data.
+ *
+ * @example
+ * ```typescript
+ *   import { useRpc } from '#storefront/composables'
+ *
+ *    const { data: shopId, fetching } = useRpc('getShopId', 'current-shop-id')
+ * ```
  */
 export declare function useRpc<N extends RpcMethodName, DataT = NormalizedRpcResponse<N>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null, ResponseT = NormalizedRpcResponse<N>>(method: N, key: string, params?: MaybeRefOrGetter<RpcMethodParameters<N> extends RpcContext ? undefined : RpcMethodParameters<N>>, options?: UseRpcOptions<N, DataT, PickKeys, DefaultT, ResponseT>): ExtendedAsyncData<ResponseT, unknown, DataT, PickKeys, DefaultT>;
 export {};

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

@@ -1,2 +1,42 @@
 import type { RpcContext, RpcMethodName, RpcMethodParameters, RpcMethodReturnType } from '@scayle/storefront-core';
+/**
+ * Provides a function for calling a specified RPC method.
+ *
+ * This function acts as a factory, returning a function that can be used to
+ * call the given RPC method. It's designed for calling RPCs in response to
+ * events or user interactions, such as clicking a button or submitting a form.
+ * `useRpcCall` accepts the RPC method name and returns a callback function.
+ * When invoked, this callback receives the RPC parameters, makes the request,
+ * and returns a promise that resolves with the RPC's response.
+ *
+ * @template N The RPC Method Name.
+ * @template P The RPC Method Parameters.
+ * @template TResult The result type of the RPC method, excluding its`Response` object.
+ * @template TakesParameters A boolean indicating whether the RPC method takes parameters.
+ *                           It's `undefined` if the parameters extend `RpcContext`.
+ *
+ * @param method The name of the RPC method.
+ *
+ * @returns A function to call the specified RPC method. This returned function
+ *          will accept the RPC method parameters (if any) and return a Promise
+ *          that resolves with the result of the RPC call.
+ *
+ * @example
+ * ```html
+ * <!-- Example of a `subscribeToNewsletter` RPC method, triggered by a form submission -->
+ * <script setup lang="ts">
+ * import { useRpcCall } from '#storefront/composables'
+ * import { ref } from 'vue';
+ *
+ * const subscribeToNewsletter = useRpcCall('subscribeToNewsletter')
+ * const email = ref('hello@scayle.com')
+ *
+ * const onSubmit = async () => {
+ *   const res = await subscribeToNewsletter({ email: email.value })
+ *
+ *   console.log(res)
+ * }
+ * </script>
+ * ```
+ */
 export declare function useRpcCall<N extends RpcMethodName, P extends RpcMethodParameters<N>, TResult extends Exclude<Awaited<RpcMethodReturnType<N>>, Response>, TakesParameters = P extends RpcContext ? undefined : boolean>(method: N): TakesParameters extends undefined ? () => Promise<TResult> : (params: P) => Promise<TResult>;

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

@@ -1,3 +1,13 @@
+/**
+ * Provides functions for managing user sessions, including login, registration, guest login, token refresh, revocation, password reset, and IDP login.
+ *
+ * This composable leverages `useRpcCall` to interact with corresponding RPC methods.
+ *
+ * @see https://scayle.dev/en/storefront-guide/developer-guide/basic-setup/sessions
+ * @see https://scayle.dev/en/storefront-guide/developer-guide/basic-setup/authentication
+ *
+ * @returns An object containing functions for various session management operations.
+ */
 export declare function useSession(): {
     login: (params: import("utility-types").Optional<import("@scayle/storefront-core").LoginRequest, "shop_id">) => Promise<never>;
     register: (params: import("utility-types").Optional<import("@scayle/storefront-core").RegisterRequest, "shop_id">) => Promise<never>;

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

@@ -1,9 +1,15 @@
 import type { ShopUser, UpdatePasswordParams } from '@scayle/storefront-core';
 import { type UseRpcReturn } from './useRpc.js';
 import { type ComputedRef } from 'vue';
+/**
+ * Extended parameters for the `useUser` composable.
+ */
 export type ExtendedUseUserParams = {
+    /** The key used for caching the user data. Defaults to 'useUser'. */
     key?: string;
+    /** Whether to fetch the user data immediately. Defaults to `true`. */
     immediate?: boolean;
+    /** Whether to enable lazy loading of user data. Defaults to `false`. */
     lazy?: boolean;
 };
 type UseUserBaseReturn = Pick<Awaited<UseRpcReturn<'getUser'>>, 'error' | 'status' | 'refresh'> & {
@@ -14,5 +20,23 @@ type UseUserBaseReturn = Pick<Awaited<UseRpcReturn<'getUser'>>, 'error' | 'statu
     customerType: ComputedRef<'new' | 'guest' | 'existing'>;
     forceRefresh: () => Promise<void>;
 };
+/**
+ * Provides user information and related actions.
+ *
+ * This composable retrieves user data via the `getUser` RPC method and offers
+ * functionalities to update user details, change passwords, and force-refresh user data.
+ * It uses `useRpc` for data fetching and provides computed properties for user status,
+ * login status, and customer type.
+ *
+ * The composable also handles caching of user data and allows for lazy loading
+ * and immediate fetching based on the provided options.
+ *
+ * @param options Options to customize the behavior of the composable,
+ *                such as caching key, immediate fetching, and lazy loading.
+ *
+ * @returns A promise that resolves to an object containing user information,
+ *          update functions, and status properties. It also includes the resolved
+ *          object directly as properties.
+ */
 export declare function useUser(options?: ExtendedUseUserParams): UseUserBaseReturn & Promise<UseUserBaseReturn>;
 export {};

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

@@ -5,6 +5,9 @@ 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';
 import type { BasketItemUpdateData } from '@scayle/storefront-core/dist/rpc/methods/index';
+/**
+ * Representation of options for configuring the `useBasket` composable.
+ */
 type UseBasketOptions = Partial<{
     params: MaybeRefOrGetter<Omit<RpcMethodParameters<'getBasket'>, 'orderCustomData'>>;
     key: string;
@@ -58,5 +61,26 @@ type UseBasketBaseReturn = Omit<Awaited<UseRpcReturn<'getBasket'>>, 'data'> & {
     /** @deprecated In a future release `shippingDates` will be removed. Consider using {@link getShippingDates} instead. */
     shippingDates: ComputedRef<(string | null)[] | undefined>;
 };
+/**
+ * Manages basket interactions. Provides functionalities for adding, removing, updating, and clearing
+ * basket items, as well as accessing basket information like items, cost, and count.
+ *
+ * This function acts as a wrapper around the `useRpc` composable for basket data,
+ * simplifying the process of fetching brand data. It internally calls `useRpc`
+ * with the provided parameters and options. It utilizes the `getCachedData` option
+ * within `useRpc` to retrieve cached basket data during hydration or from async data otherwise.
+ * This helps avoid unnecessary re-fetches and improves performance. Specifically,
+ * it checks `nuxtApp._asyncData` for existing data associated with the provided key.
+ * This approach addresses a [Nuxt typing issue](https://github.com/nuxt/nuxt/issues/26093)
+ * requiring a type assertion to `WishlistResponseData`.
+ *
+ * @param options An object containing parameters and options for all basket-related RPC calls.
+ * @param options.params Parameters for the 'getBasket' RPC call (excluding `orderCustomData`).
+ * @param key A unique key for identifying the basket instance. Defaults to 'useBasket'.
+ *
+ * @returns A promise resolving to an object with basket data, methods, and reactive properties.
+ *
+ * @throws {Error} If an item cannot be found during removal or if an item is added with a reduced quantity.  Also throws FetchError if RPC calls fail.
+ */
 export declare function useBasket({ params, }?: UseBasketOptions, key?: string): UseBasketBaseReturn & Promise<UseBasketBaseReturn>;
 export {};