@scayle/storefront-nuxt 8.10.4 → 8.11.1

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

@@ -1,4 +1,25 @@
 import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
+/**
+ * Retrieves address data for a logged-in user using the `getCategoryById` RPC method.
+ *
+ * This function acts as a wrapper around the `useRpc` composable,
+ * simplifying the process of fetching data. It internally calls `useRpc`
+ * with the provided parameters and options.
+ *
+ * @see https://scayle.dev/en/api-guides/customer-account-api/resources/customer/address/list-addresses
+ *
+ * @template DataT The type of the normalized RPC response data. Defaults to `NormalizedRpcResponse<'getCategoryById'>`.
+ * @template PickKeys The keys to pick from the data. Defaults to all keys of `DataT`.
+ * @template DefaultT The default value to use if data is not available. Defaults to `null`.
+ *
+ * @param params An object containing parameters and options for the `getCategoryById` RPC call.
+ * @param params.params The parameters for the `getCategoryById` RPC method.
+ * @param params.options The options for the underlying `useRpc` call, controlling data handling and loading state.
+ * @param key A unique key for this RPC call. Used internally by `useRpc` for caching and state management.
+ *
+ * @returns The result of the `useRpc` call, which includes the fetched data,
+ *          loading state, and any error information.
+ */
 export declare function useUserAddresses<DataT = NormalizedRpcResponse<'getShopUserAddresses'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ options, }?: Partial<{
     options: UseRpcOptions<'getShopUserAddresses', DataT, PickKeys, DefaultT>;
 }>, key?: string): UseRpcReturn<'getShopUserAddresses', DataT, PickKeys, DefaultT>;

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

@@ -1,6 +1,27 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
 import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
+/**
+ * Retrieves data for a single or multiple product variant by its ID using the `getVariantById` RPC method.
+ *
+ * This function acts as a wrapper around the `useRpc` composable,
+ * simplifying the process of fetching data. It internally calls `useRpc`
+ * with the provided parameters and options.
+ *
+ * @see https://scayle.dev/en/api-guides/storefront-api/resources/variants/get-a-variant
+ *
+ * @template DataT The type of the normalized RPC response data. Defaults to `NormalizedRpcResponse<'getVariantById'>`.
+ * @template PickKeys The keys to pick from the data. Defaults to all keys of `DataT`.
+ * @template DefaultT The default value to use if data is not available. Defaults to `null`.
+ *
+ * @param params An object containing parameters and options for the `getVariantById` RPC call.
+ * @param params.params The parameters for the `getVariantById` RPC method.
+ * @param params.options The options for the underlying `useRpc` call, controlling data handling and loading state.
+ * @param key A unique key for this RPC call. Used internally by `useRpc` for caching and state management.
+ *
+ * @returns The result of the `useRpc` call, which includes the fetched data,
+ *          loading state, and any error information.
+ */
 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>;

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

@@ -1,6 +1,9 @@
 import type { Product, WishlistItem, RpcMethodParameters } from '@scayle/storefront-core';
 import { type UseRpcReturn } from '../core/useRpc.js';
 import { type MaybeRefOrGetter, type ComputedRef } from 'vue';
+/**
+ * Representation of options for configuring the `useWishlist` composable.
+ */
 type Options = Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getWishlist'>>;
 }>;
@@ -39,5 +42,31 @@ type UseWishlistBaseReturn = Awaited<UseRpcReturn<'getWishlist'>> & {
     items: ComputedRef<WishlistItem[] | undefined>;
     products: ComputedRef<Product[]>;
 };
+/**
+ * Manages wishlist interactions. Fetches wishlist data, provides methods for adding, removing,
+ * replacing, clearing, finding, and toggling items. It leverages RPC calls for data manipulation
+ * and provides reactive properties for count, items, and products.
+ *
+ * This function acts as a wrapper around the `useRpc` composable for wishlist 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 wishlist 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`.
+ *
+ * @see https://scayle.dev/en/api-guides/storefront-api/resources/wishlists/get-a-wishlist
+ * @see https://scayle.dev/en/storefront-guide/developer-guide/basic-setup/rpc-methods#managing-shared-state-with-userpc
+ *
+ * @param params An object containing parameters and options for all wishlist-related RPC calls.
+ * @param params.params The parameters for the `useWishlist` RPC method.
+ * @param params.options The options for the underlying `useRpc` call, controlling data handling and loading state.
+ * @param key A unique key for this RPC call. Used internally by `useRpc` for caching and state management.
+ *
+ * @returns A promise that resolves to an object containing wishlist data, methods, and reactive properties.
+ *
+ * @throws {Error} If an item cannot be found during removal or replacement.
+ */
 export declare function useWishlist({ params, }?: Options, key?: string): UseWishlistBaseReturn & Promise<UseWishlistBaseReturn>;
 export {};

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

@@ -1 +1,14 @@
+/**
+ * Creates a logger instance with an `sfc` prefix.
+ *
+ * This composable provides a logging function specifically for storefront-nuxt internal operations.
+ * It wraps the generic `useLog` function and prefixes the provided subspace with `sfc` to distinguish
+ * storefront-nuxt logs from application logs. This aids in debugging and troubleshooting by clearly
+ * identifying the origin of log messages.
+ *
+ * @param subSpace The subspace for the logger. If provided, it will be prefixed with `sfc.`.
+ * If not provided, the subspace will be just `sfc`.
+ *
+ * @returns A logger instance.
+ */
 export declare function useCoreLog(subSpace: string): import("@scayle/storefront-core").Log;

package/dist/runtime/context.d.ts

@@ -4,6 +4,9 @@ import { type H3Event } from 'h3';
 import type { Log, RpcContext, Cache as CacheInterface } from '@scayle/storefront-core';
 import { StorefrontAPIClient } from '@scayle/storefront-core';
 import type { ShopConfig, StorefrontConfig } from '../module.js';
+/**
+ * Interface defining the options for the context builder.
+ */
 export interface ContextBuilderOptions {
     $cache: CacheInterface;
     $shopConfig: ShopConfig;
@@ -14,6 +17,28 @@ export interface ContextBuilderOptions {
     config: RuntimeConfig;
     event: H3Event;
 }
+/**
+ * Builds the RPC context.
+ *
+ * It builds the RPC context by gathering data from different sources like
+ * shop config, storefront config, session, etc.
+ * It initializes the SAPI client, caching function, and various context properties.
+ * It also sets up getters for IP, headers, user, access tokens,
+ * and functions for session management and user updates.
+ *
+ * @see https://scayle.dev/en/storefront-guide/developer-guide/basic-setup/rpc-methods#rpc-context
+ *
+ * @param context The context builder options.
+ * @param context.$cache The cache instance.
+ * @param context.$shopConfig The shop configuration.
+ * @param context.$storefront The storefront configuration.
+ * @param context.$log The log instance.
+ * @param context.config The runtime configuration.
+ * @param context.event The H3 event.
+ * @param context.session The session object.
+ *
+ * @returns The built RPC context.
+ */
 export declare const buildContext: (context: ContextBuilderOptions) => Promise<RpcContext>;
 declare module '@scayle/storefront-core' {
     interface AdditionalRpcContext {

package/dist/runtime/context.js

@@ -9,6 +9,8 @@ import {
 } from "@scayle/storefront-core/dist/utils/keys";
 import { useNitroApp } from "nitropack/runtime";
 import { getCachedFunction } from "./cached.js";
+import { getApiBasePath } from "./server/middleware/bootstrap-utils.js";
+import { unwrap } from "@scayle/storefront-core/dist/utils/response";
 import { fetchCampaignKey } from "./campaignKey.js";
 async function getWishlistKey(appKeys, session, $log, $shopConfig) {
   return session.data.user ? await generateWishlistKey({
@@ -28,6 +30,22 @@ async function getBasketKey(appKeys, session, $log, $shopConfig) {
     log: $log
   }) : session?.id;
 }
+function buildRpcCall(event, shopConfig, apiBasePath) {
+  const fetch = event.$fetch;
+  return async function rpcCall(method, params = void 0) {
+    const data = await fetch(`${apiBasePath}/rpc/${method}`, {
+      // @ts-expect-error Type '"POST"' is not assignable to type 'AvailableRouterMethod<`${string}/rpc/${N}`> | Uppercase<AvailableRouterMethod<`${string}/rpc/${N}`>> | undefined'.ts(2322)
+      method: "POST",
+      body: {
+        payload: params
+      },
+      headers: {
+        "x-shop-id": shopConfig.shopId.toString()
+      }
+    });
+    return await unwrap(data);
+  };
+}
 export const buildContext = async (context) => {
   const { $cache, $shopConfig, $storefront, $log, config, event, session } = context;
   const sapiConfig = $shopConfig.sapi ?? $storefront.sapi;
@@ -50,6 +68,11 @@ export const buildContext = async (context) => {
     $storefront.cache?.enabled
   );
   const { hooks } = useNitroApp();
+  const callRpc = buildRpcCall(
+    context.event,
+    $shopConfig,
+    getApiBasePath($storefront, "/")
+  );
   const rpcContext = {
     cached,
     sapiClient,
@@ -135,7 +158,8 @@ export const buildContext = async (context) => {
     updateTokens: session ? async (tokens) => {
       Object.assign(session.data, tokens);
       await session.save();
-    } : void 0
+    } : void 0,
+    callRpc
   };
   await hooks?.callHook("storefront:context:created", rpcContext);
   return rpcContext;

package/dist/runtime/createLog.d.ts

@@ -1,4 +1,20 @@
 import type { ConsolaInstance, ConsolaOptions } from 'consola';
 import type { LogLevel } from '../index.js';
 import { Log } from '@scayle/storefront-core';
+/**
+ * Creates a Consola log instance.
+ *
+ * It creates a new log instance using the provided `createConsola` function.
+ * It sets up a handler that formats log entries with the `space` and logs them
+ * using the consola instance.
+ *
+ * @see https://github.com/unjs/consola?tab=readme-ov-file#creating-a-new-instance
+ *
+ * @param createConsola Function to create a consola instance.
+ * @param createConsola.options Options for the consola instance.
+ * @param space The space for the log. Defaults to 'default-storefront'.
+ * @param level The log level.
+ *
+ * @returns The created Consola log instance.
+ */
 export default function createLog(createConsola: (options?: Partial<ConsolaOptions>) => ConsolaInstance, space: string | undefined, level: LogLevel): Log;

package/dist/runtime/handler.d.ts

@@ -1,8 +1,22 @@
 import type { RpcContext, RpcMethodName, RpcMethodParameters, RpcMethodReturnType } from '@scayle/storefront-core';
 /**
- * Handler for RPC methods
- * @param method
- * @param payload
- * @param rpcContext
+ * Handles RPC method calls, combining core RPC methods with custom Storefront RPC methods.
+ * This function acts as a central dispatcher for invoking RPC methods, determining
+ * whether the method takes parameters or not, and executing it accordingly.
+ * It additionally logs the execution time of each RPC call.
+ *
+ * @template N The RPC method name.
+ * @template P The RPC method parameters.
+ * @template TResult The awaited return type of the RPC method. This can include a `Response` object.
+ * @template TakesParameters A boolean indicating whether the method takes parameters (undefined if it doesn't).
+ * @template TParams The type of the parameters if the method takes any, otherwise null.
+ *
+ * @param method The name of the RPC method to call.
+ * @param payload The parameters for the RPC method (if any).
+ * @param rpcContext The RPC context object.
+ *
+ * @returns A Promise resolving to the result of the RPC call, which can be any valid return type or a `Response` object.
+ *
+ * @throws {Error} If the specified RPC method is not found.
  */
 export declare const handler: <N extends RpcMethodName, P extends RpcMethodParameters<N>, TResult extends Awaited<RpcMethodReturnType<N>>, TakesParameters = P extends RpcContext ? undefined : boolean, TParams = TakesParameters extends undefined ? null : P>(method: N, payload: TParams, rpcContext: RpcContext) => Promise<TResult | Response>;

package/dist/runtime/rpc/rpcCall.d.ts

@@ -2,8 +2,20 @@ import type { RpcContext, RpcMethodName, RpcMethodParameters, RpcMethodReturnTyp
 import type { NuxtApp } from 'nuxt/app';
 import type { PublicShopConfig } from '../../index.js';
 /**
- * rpcCall can be used to invoke an RPC method either on the client or server
- * It makes an HTTP request on the client and direct call on the server using $fetch
- * https://nuxt.com/docs/api/utils/dollarfetch
+ * Invokes an RPC method on the client or server.
+ * Uses an HTTP request on the client and a direct call on the server via `$fetch`.
+ *
+ * @see https://nuxt.com/docs/api/utils/dollarfetch
+ *
+ * @template N The RPC method name.
+ * @template P The RPC method parameters.
+ * @template TResult The unwrapped return type of the RPC method, excluding the Response type.
+ * @template TakesParameters A boolean indicating whether the method takes parameters (undefined if it doesn't).
+ *
+ * @param nuxtApp The Nuxt app instance.
+ * @param method The name of the RPC method to call.
+ * @param shop The public shop configuration.
+ *
+ * @returns A function that takes parameters (if required) and returns a Promise resolving to the result.
  */
 export declare const rpcCall: <N extends RpcMethodName, P extends RpcMethodParameters<N>, TResult extends Exclude<Awaited<RpcMethodReturnType<N>>, Response>, TakesParameters = P extends RpcContext ? undefined : boolean>(nuxtApp: NuxtApp, method: N, shop: PublicShopConfig) => TakesParameters extends undefined ? () => Promise<TResult> : (params: P) => Promise<TResult>;

package/dist/runtime/server/middleware/bootstrap-utils.d.ts

@@ -48,7 +48,7 @@ export declare const convertShopsToList: (shops: ShopConfig[] | ShopConfigIndexe
  *
  * @returns The API base path.
  */
-export declare function getApiBasePath(storefrontConfig: ModuleBaseOptions, baseUrl: string): string;
+export declare function getApiBasePath(storefrontConfig: Pick<ModuleBaseOptions, 'apiBasePath'>, baseUrl: string): string;
 /**
  * Retrieves the current shop configuration for a given request.
  *

package/dist/runtime/utils/promise.d.ts

@@ -1,9 +1,33 @@
 /**
- * This function accepts a Promise which has the same interface as its resolved value.
- * It returns a new Promise which extends the original Promise and the original Promise's resolve value
- * with all the properties in source.
- * @param promise
- * @param source
- * @returns
+ * Extends a Promise and its resolved value with properties from a source object.
+ *
+ * This effectively allows to treat a Promise as a regular object and
+ * extend it with custom properties, while maintaining its asynchronous behavior.
+ * These added properties are then available on the Promise itself as well as on its resolved value.
+ *
+ * @template T The type of the `Promise` and its resolved value. This should be an object type.
+ * @template U The type of the source object.
+ *
+ * @param promise The original Promise. The Promise's resolved value must have the same interface as the Promise itself.
+ * @param source The source object to merge with the Promise and its resolved value.
+ *
+ * @returns A new Promise with the properties of both the original Promise and the `source` object.
+ *          The resolved value of the new Promise also includes the merged properties.
+ *
+ * @example
+ * ```typescript
+ * const originalPromise = Promise.resolve({ initial: 'value' }) as { initial: string } & Promise<{ initial: string }>
+ * const sourceObject = { added: 'objectProperty' }
+ * const extendedPromise = extendPromise(originalPromise, sourceObject)
+ *
+ * // Access `added` property directly on the Promise:
+ * console.log(extendedPromise.added) // 'objectProperty'
+ *
+ * extendedPromise.then(result => {
+ *   // Access added property on the resolved value:
+ *   console.log(result.initial) // 'value'
+ *   console.log(result.added) // 'objectProperty'
+ * })
+ * ```
  */
 export declare function extendPromise<T extends object, U>(promise: T & Promise<T>, source: U): T & U & Promise<T & U>;

package/dist/runtime/utils/route.d.ts

@@ -1,2 +1,13 @@
 import type { LocationQuery } from 'vue-router';
+/**
+ * Retrieves the current page number from the Vue Router query object.
+ *
+ * This function attempts to extract the 'page' parameter from the provided `query` object.
+ * It handles cases where the 'page' parameter is a string and parses it as an integer.
+ * If the 'page' parameter is not a string or not present, it returns undefined.
+ *
+ * @param query The Vue Router query object.
+ *
+ * @returns The current page number as a number, or undefined if not found or invalid.
+ */
 export declare const getCurrentPage: (query: LocationQuery) => number | undefined;

package/dist/runtime/utils/seo.d.ts

@@ -12,4 +12,17 @@ import type { BreadcrumbItem } from '@scayle/storefront-core';
  * @returns The sanitized URL.
  */
 export declare const sanitizeCanonicalURL: (url: string, whitelistParams?: string[]) => string;
+/**
+ * Generates a BreadcrumbList schema for structured data based on an array of BreadcrumbItems.
+ *
+ * This function iterates through the provided `breadcrumbs` array and creates a
+ * `BreadcrumbList` object conforming to the schema.org specification.
+ * Each breadcrumb item is transformed into a `ListItem` with its position, name, and URL.
+ *
+ * @see https://schema.org/BreadcrumbList
+ *
+ * @param breadcrumbs An array of breadcrumb items used to generate the schema.
+ *
+ * @returns A BreadcrumbList schema object ready to be included in structured data.
+ */
 export declare const generateCategoryBreadcrumbSchema: (breadcrumbs: BreadcrumbItem[]) => WithContext<BreadcrumbList>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@scayle/storefront-nuxt",
   "type": "module",
-  "version": "8.10.4",
+  "version": "8.11.1",
   "description": "Nuxt integration for the SCAYLE Commerce Engine and Storefront API",
   "author": "SCAYLE Commerce Engine",
   "license": "MIT",
@@ -72,8 +72,8 @@
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
     "@scayle/h3-session": "0.6.0",
-    "@scayle/storefront-core": "8.8.0",
-    "@scayle/unstorage-compression-driver": "^0.2.3",
+    "@scayle/storefront-core": "8.10.0",
+    "@scayle/unstorage-compression-driver": "^0.2.4",
     "@vercel/nft": "0.29.2",
     "@vueuse/core": "12.7.0",
     "consola": "^3.2.3",
@@ -95,12 +95,12 @@
     "@nuxt/kit": "3.14.1592",
     "@nuxt/module-builder": "0.8.4",
     "@nuxt/schema": "3.14.1592",
-    "@nuxt/test-utils": "3.16.0",
+    "@nuxt/test-utils": "3.17.0",
     "@scayle/eslint-config-storefront": "4.4.1",
     "@scayle/eslint-plugin-vue-composable": "0.2.1",
-    "@types/node": "22.13.4",
+    "@types/node": "22.13.5",
     "dprint": "0.49.0",
-    "eslint": "9.20.1",
+    "eslint": "9.21.0",
     "eslint-formatter-gitlab": "5.1.0",
     "fishery": "2.2.3",
     "h3": "1.15.0",
@@ -110,7 +110,7 @@
     "nuxt": "3.14.1592",
     "publint": "0.2.12",
     "typescript": "5.7.3",
-    "vue-tsc": "2.2.2",
+    "vue-tsc": "2.2.4",
     "vitest": "2.1.9"
   },
   "peerDependencies": {