@scayle/storefront-nuxt 7.85.7 → 7.85.9

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @scayle/storefront-nuxt
 
+## 7.85.9
+
+### Patch Changes
+
+- Update @nuxt/module-builder to 0.6.0
+
+## 7.85.8
+
+### Patch Changes
+
+- Correct the types of `useOrder` and `useOrderConfirmation`
+  **Dependencies**
+
+- Updated dependency to @scayle/storefront-core@7.65.4
+
 ## 7.85.7
 
 ### Patch Changes

package/dist/index.d.mts

@@ -1,23 +1,13 @@
-export { e as AdditionalShopConfig, A as AppKeys, B as BapiConfig, i as CheckoutEvent, C as CheckoutShopConfig, M as ModuleBaseOptions, j as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, d as SapiConfig, a as SessionConfig, f as ShopConfig, g as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, h as StorefrontConfig } from './shared/storefront-nuxt.891170da.mjs';
-export { rpcCall } from './rpc.mjs';
+export { e as AdditionalShopConfig, A as AppKeys, B as BapiConfig, i as CheckoutEvent, C as CheckoutShopConfig, M as ModuleBaseOptions, j as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, d as SapiConfig, a as SessionConfig, f as ShopConfig, g as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, h as StorefrontConfig } from './shared/storefront-nuxt.77c99ba5.mjs';
+export { rpcCall } from './runtime/rpc/rpcCall.ts';
+export { extendPromise } from './runtime/utils/promise.ts';
 export * from '@scayle/storefront-core';
 export { LogLevel } from '@scayle/storefront-core';
 export { unwrap } from '@scayle/storefront-core/dist/utils/response';
 import '@scayle/unstorage-compression-driver';
 import 'unstorage';
-import 'zod';
+import './runtime/utils/zodSchema.ts';
 import '@nuxt/schema';
-import 'nuxt/app';
-
-/**
- * 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
- */
-declare function extendPromise<T extends object, U>(promise: T & Promise<T>, source: U): T & U & Promise<T & U>;
 
 interface RpcMethodsStorefront {
 }
@@ -26,4 +16,4 @@ declare module '@scayle/storefront-core' {
     }
 }
 
-export { type RpcMethodsStorefront, extendPromise };
+export type { RpcMethodsStorefront };

package/dist/index.d.ts

@@ -1,23 +1,13 @@
-export { e as AdditionalShopConfig, A as AppKeys, B as BapiConfig, i as CheckoutEvent, C as CheckoutShopConfig, M as ModuleBaseOptions, j as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, d as SapiConfig, a as SessionConfig, f as ShopConfig, g as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, h as StorefrontConfig } from './shared/storefront-nuxt.891170da.js';
-export { rpcCall } from './rpc.js';
+export { e as AdditionalShopConfig, A as AppKeys, B as BapiConfig, i as CheckoutEvent, C as CheckoutShopConfig, M as ModuleBaseOptions, j as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, d as SapiConfig, a as SessionConfig, f as ShopConfig, g as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, h as StorefrontConfig } from './shared/storefront-nuxt.77c99ba5.js';
+export { rpcCall } from './runtime/rpc/rpcCall.ts';
+export { extendPromise } from './runtime/utils/promise.ts';
 export * from '@scayle/storefront-core';
 export { LogLevel } from '@scayle/storefront-core';
 export { unwrap } from '@scayle/storefront-core/dist/utils/response';
 import '@scayle/unstorage-compression-driver';
 import 'unstorage';
-import 'zod';
+import './runtime/utils/zodSchema.ts';
 import '@nuxt/schema';
-import 'nuxt/app';
-
-/**
- * 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
- */
-declare function extendPromise<T extends object, U>(promise: T & Promise<T>, source: U): T & U & Promise<T & U>;
 
 interface RpcMethodsStorefront {
 }
@@ -26,4 +16,4 @@ declare module '@scayle/storefront-core' {
     }
 }
 
-export { type RpcMethodsStorefront, extendPromise };
+export type { RpcMethodsStorefront };

package/dist/index.mjs

@@ -1,18 +1,4 @@
-export { rpcCall } from './rpc.mjs';
+export { rpcCall } from './runtime/rpc/rpcCall';
+export { extendPromise } from './runtime/utils/promise';
 export * from '@scayle/storefront-core';
 export { unwrap } from '@scayle/storefront-core/dist/utils/response';
-
-function extendPromise(promise, source) {
-  const newPromise = promise.then(
-    (result) => Object.assign(result, source)
-  );
-  const withoutPromise = Object.assign({}, promise);
-  for (const key of Object.getOwnPropertyNames(
-    Promise.prototype
-  )) {
-    delete withoutPromise[key];
-  }
-  return Object.assign(newPromise, Object.assign(withoutPromise, source));
-}
-
-export { extendPromise };

package/dist/module.d.mts

@@ -1,11 +1,11 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { M as ModuleBaseOptions } from './shared/storefront-nuxt.891170da.mjs';
-export { e as AdditionalShopConfig, A as AppKeys, B as BapiConfig, i as CheckoutEvent, C as CheckoutShopConfig, j as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, d as SapiConfig, a as SessionConfig, f as ShopConfig, g as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, h as StorefrontConfig } from './shared/storefront-nuxt.891170da.mjs';
+import { M as ModuleBaseOptions } from './shared/storefront-nuxt.77c99ba5.mjs';
+export { e as AdditionalShopConfig, A as AppKeys, B as BapiConfig, i as CheckoutEvent, C as CheckoutShopConfig, j as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, d as SapiConfig, a as SessionConfig, f as ShopConfig, g as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, h as StorefrontConfig } from './shared/storefront-nuxt.77c99ba5.mjs';
 export { LogLevel } from '@scayle/storefront-core';
 import '@scayle/unstorage-compression-driver';
 import 'unstorage';
-import 'zod';
+import './runtime/utils/zodSchema.ts';
 
-declare const _default: _nuxt_schema.NuxtModule<Omit<ModuleBaseOptions, "sapi" | "bapi">>;
+declare const _default: _nuxt_schema.NuxtModule<ModuleBaseOptions, ModuleBaseOptions, false>;
 
 export { ModuleBaseOptions, _default as default };

package/dist/module.d.ts

@@ -1,11 +1,11 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { M as ModuleBaseOptions } from './shared/storefront-nuxt.891170da.js';
-export { e as AdditionalShopConfig, A as AppKeys, B as BapiConfig, i as CheckoutEvent, C as CheckoutShopConfig, j as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, d as SapiConfig, a as SessionConfig, f as ShopConfig, g as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, h as StorefrontConfig } from './shared/storefront-nuxt.891170da.js';
+import { M as ModuleBaseOptions } from './shared/storefront-nuxt.77c99ba5.js';
+export { e as AdditionalShopConfig, A as AppKeys, B as BapiConfig, i as CheckoutEvent, C as CheckoutShopConfig, j as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, d as SapiConfig, a as SessionConfig, f as ShopConfig, g as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, h as StorefrontConfig } from './shared/storefront-nuxt.77c99ba5.js';
 export { LogLevel } from '@scayle/storefront-core';
 import '@scayle/unstorage-compression-driver';
 import 'unstorage';
-import 'zod';
+import './runtime/utils/zodSchema.ts';
 
-declare const _default: _nuxt_schema.NuxtModule<Omit<ModuleBaseOptions, "sapi" | "bapi">>;
+declare const _default: _nuxt_schema.NuxtModule<ModuleBaseOptions, ModuleBaseOptions, false>;
 
 export { ModuleBaseOptions, _default as default };

package/dist/module.mjs

@@ -4,30 +4,7 @@ import { defu } from 'defu';
 import { genImport, genSafeVariableName } from 'knitwork';
 import { builtinDrivers } from 'unstorage';
 import { createConsola } from 'consola';
-import 'h3';
-import { joinURL } from 'ufo';
-
-const convertShopsToList = (shops) => {
-  if (Array.isArray(shops)) {
-    return shops;
-  }
-  return Object.values(shops);
-};
-function getApiBasePath(storefrontConfig, shop, baseUrl) {
-  const path = Array.isArray(shop.path) ? shop.path[0] : shop.path;
-  const apiPath = shop.apiBasePath || storefrontConfig.apiBasePath || "/api";
-  if (storefrontConfig.shopSelector === "path") {
-    const pathElements = [path, apiPath].filter(Boolean);
-    return joinURL(baseUrl, ...pathElements);
-  } else if (storefrontConfig.shopSelector === "path_or_default") {
-    if (shop.isDefault) {
-      return joinURL(baseUrl, apiPath);
-    }
-    const pathElements = [path, apiPath].filter(Boolean);
-    return joinURL(baseUrl, ...pathElements);
-  }
-  return joinURL(baseUrl, apiPath);
-}
+import { convertShopsToList, getApiBasePath } from './runtime/server/middleware/bootstrap.utils';
 
 function stringToBoolean(value, defaultValue = false) {
   return value ? value.toLowerCase() === "true" : defaultValue;
@@ -71,7 +48,7 @@ export default {
 }`;
 }
 const PACKAGE_NAME = "@scayle/storefront-nuxt";
-const PACKAGE_VERSION = "7.85.7";
+const PACKAGE_VERSION = "7.85.9";
 const logger = createConsola({
   fancy: true,
   formatOptions: {
@@ -81,6 +58,9 @@ const logger = createConsola({
   defaults: {
     tag: PACKAGE_NAME
   }
+  // At runtime consola/basic will be loaded which supports the fancy option
+  // However when typechecking it will resolve to consola/browser which does have the fancy option
+  // This assertion avoids the typescript error
 });
 const module = defineNuxtModule({
   meta: {

package/dist/rpc.d.mts

@@ -1,16 +1 @@
-import { RpcMethodName, RpcMethodParameters, RpcMethodReturnType, RpcContext } from '@scayle/storefront-core';
-import { NuxtApp } from 'nuxt/app';
-import { P as PublicShopConfig } from './shared/storefront-nuxt.891170da.mjs';
-import '@scayle/unstorage-compression-driver';
-import 'unstorage';
-import 'zod';
-import '@nuxt/schema';
-
-/**
- * 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
- */
-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>;
-
-export { rpcCall };
+export { rpcCall } from './runtime/rpc/rpcCall.ts';

package/dist/rpc.d.ts

@@ -1,16 +1 @@
-import { RpcMethodName, RpcMethodParameters, RpcMethodReturnType, RpcContext } from '@scayle/storefront-core';
-import { NuxtApp } from 'nuxt/app';
-import { P as PublicShopConfig } from './shared/storefront-nuxt.891170da.js';
-import '@scayle/unstorage-compression-driver';
-import 'unstorage';
-import 'zod';
-import '@nuxt/schema';
-
-/**
- * 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
- */
-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>;
-
-export { rpcCall };
+export { rpcCall } from './runtime/rpc/rpcCall.ts';

package/dist/rpc.mjs

@@ -1,20 +1 @@
-import { unwrap } from '@scayle/storefront-core/dist/utils/response';
-
-const rpcCall = (nuxtApp, method, shop) => {
-  const fetch = nuxtApp.ssrContext?.event.$fetch ?? $fetch;
-  return async (params = void 0) => {
-    const data = await fetch(`${shop.apiBasePath ?? "/api"}/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": shop.shopId.toString()
-      }
-    });
-    return await unwrap(data);
-  };
-};
-
-export { rpcCall };
+export { rpcCall } from './runtime/rpc/rpcCall';

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

@@ -1,2 +1,56 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string | true | string[] | import("@scayle/storefront-core").ShopUser | import("@scayle/storefront-api").Product | import("@scayle/storefront-api").BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant> | {
+    type: "failure";
+    statusCode: number;
+    basket: import("@scayle/storefront-api").BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>;
+} | {
+    readonly type: "success";
+    readonly basket: import("@scayle/storefront-api").BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>;
+} | {
+    readonly type: "failure";
+    readonly basket: import("@scayle/storefront-api").BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>;
+    readonly errors: import("@scayle/storefront-api").AddOrUpdateItemError[];
+} | import("@scayle/storefront-api").BrandsEndpointResponseData | import("@scayle/storefront-api").Brand | {
+    categories: import("@scayle/storefront-api").Category[];
+    activeNode: undefined;
+} | import("@scayle/storefront-api").Category | {
+    categories: import("@scayle/storefront-api").Category;
+    activeNode: import("@scayle/storefront-api").Category;
+} | import("@scayle/storefront-core").Order | {
+    category: string | undefined;
+    categoryId: number | undefined;
+} | 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;
+    };
+} | import("@scayle/storefront-api").TypeaheadSuggestionsEndpointResponseData | 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 | Response | import("@scayle/storefront-core").ShopUserAddress[] | {
+    accessToken: string;
+    checkoutJwt: string;
+} | import("@scayle/storefront-api").VariantDetail[] | import("@scayle/storefront-api").NavigationAllEndpointResponseData | import("@scayle/storefront-api").NavigationTree | {
+    success: true;
+} | {
+    success: false;
+} | {
+    result: true;
+} | {
+    result: false;
+} | import("@scayle/storefront-api").PromotionsEndpointResponseData | {
+    [k: string]: string;
+} | {
+    message: string;
+} | null | undefined>>;
 export default _default;

package/dist/runtime/api/rpcHandler.mjs

@@ -3,7 +3,7 @@ import { purifySensitiveData } from "@scayle/storefront-core";
 import { trace, SpanStatusCode } from "@opentelemetry/api";
 import { handler } from "../handler.mjs";
 import { resolveError } from "../error/handler.mjs";
-import { useNitroApp } from "#imports";
+import { useNitroApp } from "nitropack/runtime";
 const tracer = trace.getTracer(
   "storefront-nuxt",
   "__sfc_version"

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

@@ -1,2 +1,2 @@
 import type { PublicShopConfig } from '../../../module';
-export declare function useAvailableShops(): import("vue").Ref<PublicShopConfig[]>;
+export declare function useAvailableShops(): import("vue").Ref<PublicShopConfig[], PublicShopConfig[]>;

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

@@ -13,11 +13,11 @@ export type NormalizedRpcResponse<N extends RpcMethodName> = Exclude<Awaited<Rpc
 /**
  * Extend AsyncDataOptions with autoFetch (deprecated) and lazy (unused)
  */
-export type UseRpcOptions<N extends RpcMethodName, DataT = NormalizedRpcResponse<N>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null> = RpcOptions & AsyncDataOptions<NormalizedRpcResponse<N>, DataT, PickKeys, DefaultT>;
+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>;
 /**
  * The return type of a composable based on useRpc
  */
-export type UseRpcReturn<N extends RpcMethodName, DataT = NormalizedRpcResponse<N>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null> = ExtendedAsyncData<NormalizedRpcResponse<N>, unknown, DataT, PickKeys, DefaultT>;
+export type 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>>;
@@ -50,5 +50,5 @@ export type ExtendedAsyncData<ResT, ErrorT = unknown, DataT = ResT, PickKeys ext
  * But anything passed here will take precedence.
  * @see {@link https://nuxt.com/docs/api/composables/use-async-data#params}
  */
-export declare function useRpc<N extends RpcMethodName, DataT = NormalizedRpcResponse<N>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>(method: N, key: string, params?: MaybeRefOrGetter<RpcMethodParameters<N> extends RpcContext ? undefined : RpcMethodParameters<N>>, options?: UseRpcOptions<N, DataT, PickKeys, DefaultT>): ExtendedAsyncData<NormalizedRpcResponse<N>, unknown, DataT, PickKeys, DefaultT>;
+export 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/storefront/useFacet.d.ts

@@ -16,17 +16,19 @@ type Options = Partial<{
 }>;
 export declare function useFacet({ key: optionsKey, params, }?: Options, _key?: string): {
     filters: import("vue").ComputedRef<import("@scayle/storefront-api").FiltersEndpointResponseData | undefined>;
-    filtersFetching: import("vue").Ref<boolean>;
+    filtersFetching: import("vue").Ref<boolean, boolean>;
     unfilteredCount: import("vue").ComputedRef<number | undefined>;
-    filterStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
-    filterError: import("vue").Ref<any>;
+    filterStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus, import("nuxt/app").AsyncDataRequestStatus>;
+    filterError: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | null, import("nuxt/app").NuxtError<unknown> | null>;
     productCountData: import("vue").Ref<{
         count: number;
+    } | null, {
+        count: number;
     } | null>;
     refreshProductCount: ({ where, }?: FilterParams) => Promise<void>;
-    productCountFetching: import("vue").Ref<boolean>;
-    productCountError: import("vue").Ref<any>;
-    productCountStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
+    productCountFetching: import("vue").Ref<boolean, boolean>;
+    productCountError: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | null, import("nuxt/app").NuxtError<unknown> | null>;
+    productCountStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus, import("nuxt/app").AsyncDataRequestStatus>;
     products: import("vue").ComputedRef<import("@scayle/storefront-api").Product[] | undefined>;
     pagination: import("vue").ComputedRef<{
         current: number;
@@ -38,15 +40,15 @@ export declare function useFacet({ key: optionsKey, params, }?: Options, _key?:
         next: number;
         last: number;
     } | undefined>;
-    productsFetching: import("vue").Ref<boolean>;
+    productsFetching: import("vue").Ref<boolean, boolean>;
     filterProducts: ({ where, page, sort, orFiltersOperator, }: FilterParams) => Promise<void>;
-    productError: import("vue").Ref<any>;
-    productStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
+    productError: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | null, import("nuxt/app").NuxtError<unknown> | null>;
+    productStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus, import("nuxt/app").AsyncDataRequestStatus>;
     categories: import("vue").ComputedRef<import("@scayle/storefront-api").Category | import("@scayle/storefront-api").Category[] | undefined>;
     selectedCategory: import("vue").ComputedRef<import("@scayle/storefront-api").Category | undefined>;
-    categoriesFetching: import("vue").Ref<boolean>;
-    categoriesError: import("vue").Ref<any>;
-    categoriesStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
+    categoriesFetching: import("vue").Ref<boolean, boolean>;
+    categoriesError: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | null, import("nuxt/app").NuxtError<unknown> | null>;
+    categoriesStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus, import("nuxt/app").AsyncDataRequestStatus>;
     fetchProducts: ({ path, page, perPage, where, sort, pricePromotionKey, cache, orFiltersOperator, }: FilterParams & {
         path: string;
         pricePromotionKey?: string;
@@ -55,17 +57,19 @@ export declare function useFacet({ key: optionsKey, params, }?: Options, _key?:
     fetchPage: (pageToFetch: number) => Promise<void>;
 } & Promise<{
     filters: import("vue").ComputedRef<import("@scayle/storefront-api").FiltersEndpointResponseData | undefined>;
-    filtersFetching: import("vue").Ref<boolean>;
+    filtersFetching: import("vue").Ref<boolean, boolean>;
     unfilteredCount: import("vue").ComputedRef<number | undefined>;
-    filterStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
-    filterError: import("vue").Ref<any>;
+    filterStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus, import("nuxt/app").AsyncDataRequestStatus>;
+    filterError: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | null, import("nuxt/app").NuxtError<unknown> | null>;
     productCountData: import("vue").Ref<{
         count: number;
+    } | null, {
+        count: number;
     } | null>;
     refreshProductCount: ({ where, }?: FilterParams) => Promise<void>;
-    productCountFetching: import("vue").Ref<boolean>;
-    productCountError: import("vue").Ref<any>;
-    productCountStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
+    productCountFetching: import("vue").Ref<boolean, boolean>;
+    productCountError: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | null, import("nuxt/app").NuxtError<unknown> | null>;
+    productCountStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus, import("nuxt/app").AsyncDataRequestStatus>;
     products: import("vue").ComputedRef<import("@scayle/storefront-api").Product[] | undefined>;
     pagination: import("vue").ComputedRef<{
         current: number;
@@ -77,15 +81,15 @@ export declare function useFacet({ key: optionsKey, params, }?: Options, _key?:
         next: number;
         last: number;
     } | undefined>;
-    productsFetching: import("vue").Ref<boolean>;
+    productsFetching: import("vue").Ref<boolean, boolean>;
     filterProducts: ({ where, page, sort, orFiltersOperator, }: FilterParams) => Promise<void>;
-    productError: import("vue").Ref<any>;
-    productStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
+    productError: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | null, import("nuxt/app").NuxtError<unknown> | null>;
+    productStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus, import("nuxt/app").AsyncDataRequestStatus>;
     categories: import("vue").ComputedRef<import("@scayle/storefront-api").Category | import("@scayle/storefront-api").Category[] | undefined>;
     selectedCategory: import("vue").ComputedRef<import("@scayle/storefront-api").Category | undefined>;
-    categoriesFetching: import("vue").Ref<boolean>;
-    categoriesError: import("vue").Ref<any>;
-    categoriesStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
+    categoriesFetching: import("vue").Ref<boolean, boolean>;
+    categoriesError: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | null, import("nuxt/app").NuxtError<unknown> | null>;
+    categoriesStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus, import("nuxt/app").AsyncDataRequestStatus>;
     fetchProducts: ({ path, page, perPage, where, sort, pricePromotionKey, cache, orFiltersOperator, }: FilterParams & {
         path: string;
         pricePromotionKey?: string;

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

@@ -1,25 +1,26 @@
 import type { RpcMethodParameters, Order } from '@scayle/storefront-core';
-import { type RpcOptions, type UseRpcReturn } from '../core/useRpc';
-import type { Ref, MaybeRefOrGetter } from 'vue';
-type Options = Partial<{
-    params: MaybeRefOrGetter<RpcMethodParameters<'getOrderById'>>;
-    options: RpcOptions;
-    /** @deprecated use the second argument of the composable to define the key */
-    key: string;
-}>;
+import type { AsyncDataOptions } from 'nuxt/app';
+import { type RpcOptions, type KeysOf, type ExtendedAsyncData } from '../core/useRpc';
+import type { MaybeRefOrGetter } from 'vue';
 type ItemsType = Exclude<Order['items'], undefined>;
 type NewItemsType<P, V> = Exclude<ItemsType[number], 'product' | 'variant'> & {
     product: P;
     variant: V;
 };
-type UserOrderBaseReturn<P, V> = Pick<Awaited<UseRpcReturn<'getOrderById'>>, 'error' | 'status' | 'fetch' | 'fetching' | 'refresh'> & {
-    data: Ref<Order & {
-        items?: NewItemsType<P, V>[];
-    }>;
-};
 export declare function useOrder<P = {
     [k: string]: unknown;
 }, V = {
     [k: string]: unknown;
-}>({ params, options, key: _key }?: Options, key?: string): UserOrderBaseReturn<P, V> & Promise<UserOrderBaseReturn<P, V>>;
+}, DataT = Order & {
+    items?: NewItemsType<P, V>[];
+}, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key }?: {
+    params?: MaybeRefOrGetter<RpcMethodParameters<'getOrderById'>>;
+    options?: RpcOptions & 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>;
 export {};

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

@@ -1,27 +1,11 @@
-import { useRpc } from "../core/useRpc.mjs";
-import { extendPromise } from "../../utils/promise.mjs";
+import {
+  useRpc
+} from "../core/useRpc.mjs";
 export function useOrder({ params, options, key: _key } = {}, key) {
-  const promise = useRpc(
+  return useRpc(
     "getOrderById",
     _key ?? key ?? "useOrder",
     params,
     options
   );
-  const {
-    data,
-    fetch,
-    fetching,
-    error,
-    refresh,
-    status
-  } = promise;
-  const _data = data;
-  return extendPromise(promise.then(() => ({})), {
-    data: _data,
-    fetch,
-    fetching,
-    error,
-    refresh,
-    status
-  });
 }

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

@@ -1,25 +1,26 @@
 import type { RpcMethodParameters, Order } from '@scayle/storefront-core';
-import type { RpcOptions, UseRpcReturn } from '../core/useRpc';
-import type { Ref, MaybeRefOrGetter } from 'vue';
-type Options = Partial<{
-    params: MaybeRefOrGetter<RpcMethodParameters<'getOrderDataByCbd'>>;
-    options: RpcOptions;
-    /** @deprecated use the second argument of the composable to define the key */
-    key: string;
-}>;
+import type { AsyncDataOptions } from 'nuxt/app';
+import type { RpcOptions, ExtendedAsyncData, KeysOf } from '../core/useRpc';
+import type { MaybeRefOrGetter } from 'vue';
 type ItemsType = Exclude<Order['items'], undefined>;
 type NewItemsType<P, V> = Exclude<ItemsType[number], 'product' | 'variant'> & {
     product: P;
     variant: V;
 };
-type UseOrderConfirmationBaseReturn<P, V> = Pick<Awaited<UseRpcReturn<'getOrderDataByCbd'>>, 'error' | 'status' | 'fetch' | 'fetching' | 'refresh'> & {
-    data: Ref<Order & {
-        items?: NewItemsType<P, V>[];
-    }>;
-};
 export declare function useOrderConfirmation<P = {
     [k: string]: unknown;
 }, V = {
     [k: string]: unknown;
-}>({ params, options, key: _key }?: Options, key?: string): UseOrderConfirmationBaseReturn<P, V> & Promise<UseOrderConfirmationBaseReturn<P, V>>;
+}, DataT = Order & {
+    items?: NewItemsType<P, V>[];
+}, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key }?: {
+    params?: MaybeRefOrGetter<RpcMethodParameters<'getOrderDataByCbd'>>;
+    options?: RpcOptions & 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>;
 export {};

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

@@ -1,27 +1,9 @@
 import { useRpc } from "../core/useRpc.mjs";
-import { extendPromise } from "../../utils/promise.mjs";
 export function useOrderConfirmation({ params, options, key: _key } = {}, key) {
-  const promise = useRpc(
+  return useRpc(
     "getOrderDataByCbd",
     _key ?? key ?? "useOrderConfirmation",
     params,
     options
   );
-  const {
-    data,
-    fetch,
-    fetching,
-    error,
-    refresh,
-    status
-  } = promise;
-  const _data = data;
-  return extendPromise(promise.then(() => ({})), {
-    fetch,
-    fetching,
-    error,
-    refresh,
-    status,
-    data: _data
-  });
 }

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

@@ -5,9 +5,9 @@ type Options = Partial<{
 }>;
 /** @deprecated `useSearch` is deprecated. Please, use `useSearchSuggestions` or `useSearchResolve` */
 export declare function useSearch({ params, key }?: Options): {
-    data: import("vue").Ref<TypeaheadSuggestionsEndpointResponseData | undefined>;
-    pending: import("vue").Ref<boolean>;
-    searchQuery: import("vue").Ref<string>;
+    data: import("vue").Ref<TypeaheadSuggestionsEndpointResponseData | undefined, TypeaheadSuggestionsEndpointResponseData | undefined>;
+    pending: import("vue").Ref<boolean, boolean>;
+    searchQuery: import("vue").Ref<string, string>;
     resetSearch: () => void;
     search: ({ term, slug, productLimit }: SearchInput) => Promise<void>;
 };

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

@@ -8,8 +8,8 @@ export type SearchOptions = Partial<{
     key: string;
 }>;
 export declare function useStorefrontSearch(searchQuery: Ref<string>, { params, key }?: SearchOptions): {
-    data: import("vue").Ref<SearchV2SuggestionsEndpointResponseData | undefined>;
-    pending: import("vue").Ref<boolean>;
+    data: Ref<SearchV2SuggestionsEndpointResponseData | undefined, SearchV2SuggestionsEndpointResponseData | undefined>;
+    pending: Ref<boolean, boolean>;
     resetSearch: () => void;
     getSearchSuggestions: () => Promise<void>;
     resolveSearch: () => Promise<import("@scayle/storefront-api").SearchEntity | null | undefined>;