@scayle/storefront-nuxt 7.74.0 → 7.75.1

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

@@ -6,37 +6,35 @@ import {
   HttpStatusCode,
   HttpStatusMessage
 } from "@scayle/storefront-core";
-import { useNuxtApp, useAsyncData } from "nuxt/app";
+import { useNuxtApp } from "nuxt/app";
 import { computed } from "vue";
 import { rpcCall } from "../../rpc/rpcCall.mjs";
+import { extendPromise } from "../../utils/promise.mjs";
+import { useRpc } from "../core/useRpc.mjs";
 import { useCurrentShop } from "../core/useCurrentShop.mjs";
 import { toValue, toRef } from "#imports";
-export async function useBasket({
+export function useBasket({
   params,
   key = "useBasket"
 } = {}) {
   const nuxtApp = useNuxtApp();
   const shop = useCurrentShop();
+  const asyncData = useRpc("getBasket", key, params, {
+    server: false,
+    // TODO: In some cases it might be ok to fetch on server
+    watch: [toRef(params)],
+    dedupe: "defer",
+    getCachedData: (key2) => {
+      return toValue(nuxtApp._asyncData[key2]?.data) ?? void 0;
+    }
+  });
   const {
     data,
     pending: fetching,
     error,
     refresh: fetch,
     status
-  } = await useAsyncData(
-    key,
-    () => rpcCall(nuxtApp, "getBasket", toValue(shop))(toValue(params)),
-    {
-      server: false,
-      // TODO: In some cases it might be ok to fetch on server
-      watch: [toRef(params)],
-      dedupe: "defer",
-      getCachedData: (key2) => {
-        return toValue(nuxtApp._asyncData[key2]?.data) ?? void 0;
-      },
-      default: () => void 0
-    }
-  );
+  } = asyncData;
   const addItem = async ({
     variantId,
     promotionId,
@@ -134,7 +132,7 @@ export async function useBasket({
   const shippingDates = computed(
     () => packages.value ? getShippingDates(packages.value) : void 0
   );
-  return {
+  return extendPromise(asyncData, {
     data,
     items,
     cost,
@@ -157,5 +155,5 @@ export async function useBasket({
     mergeBaskets,
     error,
     status
-  };
+  });
 }

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

@@ -1,16 +1,11 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { RpcOptions } from '../core/useRpc';
+import type { UseRpcOptions, UseRpcReturn } from '../core/useRpc';
 import type { MaybeRefOrGetter } from '#imports';
 type Options = Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getBrandById'>>;
-    options: RpcOptions;
+    options: UseRpcOptions<'getBrandById'>;
+    /** @deprecated use the second argument of the composable to define the key */
     key: string;
 }>;
-export declare function useBrand({ params, options, key, }?: Options): Promise<{
-    data: import("vue").Ref<import("@scayle/storefront-api").Brand | undefined>;
-    fetching: import("vue").Ref<boolean>;
-    fetch: () => Promise<void>;
-    error: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | undefined>;
-    status: import("vue").Ref<import("../core/useRpc").Status>;
-}>;
+export declare function useBrand({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'getBrandById'>;
 export {};

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

@@ -1,20 +1,13 @@
 import { useRpc } from "../core/useRpc.mjs";
-export async function useBrand({
+export function useBrand({
   params,
   options,
-  key = "useBrand"
-} = {}) {
-  const { data, fetching, fetch, error, status } = await useRpc(
+  key: _key
+} = {}, key) {
+  return useRpc(
     "getBrandById",
-    key,
+    _key ?? key ?? "useBrand",
     params,
     options
   );
-  return {
-    data,
-    fetching,
-    fetch,
-    error,
-    status
-  };
 }

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

@@ -1,16 +1,11 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { RpcOptions } from '../core/useRpc';
+import type { UseRpcOptions, UseRpcReturn } from '../core/useRpc';
 import type { MaybeRefOrGetter } from '#imports';
 type Options = Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getBrands'>>;
-    options: RpcOptions;
+    options: UseRpcOptions<'getBrands'>;
+    /** @deprecated use the second argument of the composable to define the key */
     key: string;
 }>;
-export declare function useBrands({ params, options, key, }?: Options): Promise<{
-    data: import("vue").Ref<import("@scayle/storefront-api").BrandsEndpointResponseData | undefined>;
-    fetching: import("vue").Ref<boolean>;
-    fetch: () => Promise<void>;
-    error: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | undefined>;
-    status: import("vue").Ref<import("../core/useRpc").Status>;
-}>;
+export declare function useBrands({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'getBrands'>;
 export {};

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

@@ -1,20 +1,13 @@
 import { useRpc } from "../core/useRpc.mjs";
-export async function useBrands({
+export function useBrands({
   params,
   options,
-  key = "useBrands"
-} = {}) {
-  const { data, fetching, fetch, error, status } = await useRpc(
+  key: _key
+} = {}, key) {
+  return useRpc(
     "getBrands",
-    key,
+    _key ?? key ?? "useBrand",
     params,
     options
   );
-  return {
-    data,
-    fetching,
-    fetch,
-    error,
-    status
-  };
 }

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

@@ -1,23 +1,33 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { RpcOptions } from '../core/useRpc';
+import type { UseRpcOptions } from '../core/useRpc';
 import type { MaybeRefOrGetter } from '#imports';
 type Options = Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getCategoriesByPath'>>;
-    options: RpcOptions;
+    options: UseRpcOptions<'getCategoriesByPath'>;
+    /** @deprecated use the second argument of the composable to define the key */
     key: string;
 }>;
-export declare function useCategories({ params, options, key, }?: Options): Promise<{
-    data: import("vue").Ref<{
-        categories: import("@scayle/storefront-api").Category[];
-        activeNode: undefined;
-    } | {
-        categories: import("@scayle/storefront-api").Category;
-        activeNode: import("@scayle/storefront-api").Category;
-    } | undefined>;
+export declare function useCategories({ params, options, key: _key, }?: Options, key?: string): import("nuxt/dist/app/composables/asyncData")._AsyncData<{
+    categories: import("@scayle/storefront-api").Category[];
+    activeNode: undefined;
+} | {
+    categories: import("@scayle/storefront-api").Category;
+    activeNode: import("@scayle/storefront-api").Category;
+}, import("nuxt/app").NuxtError<unknown> | null> & {
     fetching: import("vue").Ref<boolean>;
-    fetch: () => Promise<void>;
-    error: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | undefined>;
-    status: import("vue").Ref<import("../core/useRpc").Status>;
+    fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions | undefined) => Promise<void>;
+} & {
+    getCategoryById: (id: number, includeHidden?: true) => Promise<import("@scayle/storefront-api").Category>;
+} & Promise<import("nuxt/dist/app/composables/asyncData")._AsyncData<{
+    categories: import("@scayle/storefront-api").Category[];
+    activeNode: undefined;
+} | {
+    categories: import("@scayle/storefront-api").Category;
+    activeNode: import("@scayle/storefront-api").Category;
+}, import("nuxt/app").NuxtError<unknown> | null> & {
+    fetching: import("vue").Ref<boolean>;
+    fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions | undefined) => Promise<void>;
+} & {
     getCategoryById: (id: number, includeHidden?: true) => Promise<import("@scayle/storefront-api").Category>;
 }>;
 export {};

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

@@ -2,16 +2,17 @@ import { useNuxtApp } from "nuxt/app";
 import { useRpc } from "../core/useRpc.mjs";
 import { useCurrentShop } from "../core/useCurrentShop.mjs";
 import { rpcCall } from "../../rpc/rpcCall.mjs";
-export async function useCategories({
+import { extendPromise } from "../../utils/promise.mjs";
+export function useCategories({
   params,
   options,
-  key = "useCategories"
-} = {}) {
+  key: _key
+} = {}, key) {
   const currentShop = useCurrentShop();
   const nuxtApp = useNuxtApp();
-  const { data, fetching, fetch, error, status } = await useRpc(
+  const useRpcPromise = useRpc(
     "getCategoriesByPath",
-    key,
+    _key ?? key ?? "useCategories",
     params,
     options
   );
@@ -20,12 +21,7 @@ export async function useCategories({
     "getCategoryById",
     currentShop.value ?? void 0
   );
-  return {
-    data,
-    fetching,
-    fetch,
-    error,
-    status,
+  return extendPromise(useRpcPromise, {
     getCategoryById: (id, includeHidden) => getCategoryById({ id, includeHidden })
-  };
+  });
 }

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

@@ -1,16 +1,11 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { RpcOptions } from '../core/useRpc';
+import type { UseRpcOptions, UseRpcReturn } from '../core/useRpc';
 import type { MaybeRefOrGetter } from '#imports';
 type Options = Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getCategoryById'>>;
-    options: RpcOptions;
+    options: UseRpcOptions<'getCategoryById'>;
+    /** @deprecated use the second argument of the composable to define the key */
     key: string;
 }>;
-export declare function useCategoryById({ params, options, key, }?: Options): Promise<{
-    data: import("vue").Ref<import("@scayle/storefront-api").Category | undefined>;
-    fetching: import("vue").Ref<boolean>;
-    fetch: () => Promise<void>;
-    error: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | undefined>;
-    status: import("vue").Ref<import("../core/useRpc").Status>;
-}>;
+export declare function useCategoryById({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'getCategoryById'>;
 export {};

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

@@ -1,20 +1,13 @@
 import { useRpc } from "../core/useRpc.mjs";
-export async function useCategoryById({
+export function useCategoryById({
   params,
   options,
-  key = "useCategoryById"
-} = {}) {
-  const { data, fetching, fetch, error, status } = await useRpc(
+  key: _key
+} = {}, key) {
+  return useRpc(
     "getCategoryById",
-    key,
+    _key ?? key ?? "useCategoryById",
     params,
     options
   );
-  return {
-    data,
-    fetching,
-    fetch,
-    error,
-    status
-  };
 }

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

@@ -1,16 +1,11 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { RpcOptions } from '../core/useRpc';
+import type { UseRpcOptions, UseRpcReturn } from '../core/useRpc';
 import type { MaybeRefOrGetter } from '#imports';
 type Options = {
     params: MaybeRefOrGetter<RpcMethodParameters<'getCategoryByPath'>>;
-    options?: RpcOptions;
+    options?: UseRpcOptions<'getCategoryByPath'>;
+    /** @deprecated use the second argument of the composable to define the key */
     key: string;
 };
-export declare function useCategoryByPath({ params, options, key, }: Options): Promise<{
-    data: import("vue").Ref<import("@scayle/storefront-api").Category | undefined>;
-    fetching: import("vue").Ref<boolean>;
-    fetch: () => Promise<void>;
-    error: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | undefined>;
-    status: import("vue").Ref<import("../core/useRpc").Status>;
-}>;
+export declare function useCategoryByPath({ params, options, key: _key, }: Options, key?: string): UseRpcReturn<'getCategoryByPath'>;
 export {};

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

@@ -1,20 +1,13 @@
 import { useRpc } from "../core/useRpc.mjs";
-export async function useCategoryByPath({
+export function useCategoryByPath({
   params,
   options,
-  key = "useCategoryByPath"
-}) {
-  const { data, fetching, fetch, error, status } = await useRpc(
+  key: _key
+}, key) {
+  return useRpc(
     "getCategoryByPath",
-    key,
+    _key ?? key ?? "useCategoryByPath",
     params,
     options
   );
-  return {
-    data,
-    fetching,
-    fetch,
-    error,
-    status
-  };
 }

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

@@ -1,16 +1,11 @@
 import { type RpcMethodParameters } from '@scayle/storefront-core';
-import { type RpcOptions } from '../core/useRpc';
+import { type UseRpcOptions, type UseRpcReturn } from '../core/useRpc';
 import { type MaybeRefOrGetter } from '#imports';
 type Options = Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getCurrentPromotions'>>;
-    options: RpcOptions;
+    options: UseRpcOptions<'getCurrentPromotions'>;
+    /** @deprecated use the second argument of the composable to define the key */
     key: string;
 }>;
-export declare function useCurrentPromotions({ params, options, key, }?: Options): Promise<{
-    data: import("vue").Ref<import("@scayle/storefront-api").PromotionsEndpointResponseData | undefined>;
-    fetching: import("vue").Ref<boolean>;
-    fetch: () => Promise<void>;
-    error: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | undefined>;
-    status: import("vue").Ref<import("../core/useRpc").Status>;
-}>;
+export declare function useCurrentPromotions({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'getCurrentPromotions'>;
 export {};

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

@@ -1,20 +1,13 @@
 import { useRpc } from "../core/useRpc.mjs";
-export async function useCurrentPromotions({
+export function useCurrentPromotions({
   params,
   options,
-  key = "useCurrentPromotions"
-} = {}) {
-  const { data, fetching, fetch, error, status } = await useRpc(
+  key: _key
+} = {}, key) {
+  return useRpc(
     "getCurrentPromotions",
-    key,
+    _key ?? key ?? "useCurrentPromotions",
     params,
     options
   );
-  return {
-    data,
-    fetching,
-    fetch,
-    error,
-    status
-  };
 }

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

@@ -11,22 +11,23 @@ type FacetParams = Partial<{
 };
 type Options = Partial<{
     params: FacetParams;
+    /** @deprecated use the second argument of the composable to define the key */
     key: string;
 }>;
-export declare function useFacet({ key, params, }?: Options): Promise<{
-    filters: import("vue").ComputedRef<import("@scayle/storefront-api").FiltersEndpointResponseData | undefined>;
+export declare function useFacet({ key: optionsKey, params, }?: Options, _key?: string): {
+    filters: import("vue").ComputedRef<import("@scayle/storefront-api").FiltersEndpointResponseData>;
     filtersFetching: import("vue").Ref<boolean>;
-    unfilteredCount: import("vue").ComputedRef<number | undefined>;
-    filterStatus: import("vue").Ref<import("..").Status>;
-    filterError: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | undefined>;
+    unfilteredCount: import("vue").ComputedRef<number>;
+    filterStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
+    filterError: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | null>;
     productCountData: import("vue").Ref<{
         count: number;
-    } | undefined>;
+    }>;
     refreshProductCount: ({ where, }?: FilterParams) => Promise<void>;
     productCountFetching: import("vue").Ref<boolean>;
-    productCountError: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | undefined>;
-    productCountStatus: import("vue").Ref<import("..").Status>;
-    products: import("vue").ComputedRef<import("@scayle/storefront-api").Product[] | undefined>;
+    productCountError: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | null>;
+    productCountStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
+    products: import("vue").ComputedRef<import("@scayle/storefront-api").Product[]>;
     pagination: import("vue").ComputedRef<{
         current: number;
         total: number;
@@ -36,16 +37,60 @@ export declare function useFacet({ key, params, }?: Options): Promise<{
         prev: number;
         next: number;
         last: number;
-    } | undefined>;
+    }>;
     productsFetching: import("vue").Ref<boolean>;
     filterProducts: ({ where, page, sort, orFiltersOperator, }: FilterParams) => Promise<void>;
-    productError: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | undefined>;
-    productStatus: import("vue").Ref<import("..").Status>;
-    categories: import("vue").ComputedRef<import("@scayle/storefront-api").Category | import("@scayle/storefront-api").Category[] | undefined>;
+    productError: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | null>;
+    productStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
+    categories: import("vue").ComputedRef<import("@scayle/storefront-api").Category | import("@scayle/storefront-api").Category[]>;
     selectedCategory: import("vue").ComputedRef<import("@scayle/storefront-api").Category | undefined>;
     categoriesFetching: import("vue").Ref<boolean>;
-    categoriesError: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | undefined>;
-    categoriesStatus: import("vue").Ref<import("..").Status>;
+    categoriesError: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | null>;
+    categoriesStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
+    fetchProducts: ({ path, page, perPage, where, sort, pricePromotionKey, cache, orFiltersOperator, }: FilterParams & {
+        path: string;
+        pricePromotionKey?: string | undefined;
+        cache?: Partial<{
+            ttl: number;
+            cacheKey: string;
+            cacheKeyPrefix: string;
+            timeout: number;
+        }> | undefined;
+    }) => Promise<true | undefined>;
+    fetchPage: (pageToFetch: number) => Promise<void>;
+} & Promise<{
+    filters: import("vue").ComputedRef<import("@scayle/storefront-api").FiltersEndpointResponseData>;
+    filtersFetching: import("vue").Ref<boolean>;
+    unfilteredCount: import("vue").ComputedRef<number>;
+    filterStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
+    filterError: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | null>;
+    productCountData: import("vue").Ref<{
+        count: number;
+    }>;
+    refreshProductCount: ({ where, }?: FilterParams) => Promise<void>;
+    productCountFetching: import("vue").Ref<boolean>;
+    productCountError: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | null>;
+    productCountStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
+    products: import("vue").ComputedRef<import("@scayle/storefront-api").Product[]>;
+    pagination: import("vue").ComputedRef<{
+        current: number;
+        total: number;
+        perPage: number;
+        page: number;
+        first: number;
+        prev: number;
+        next: number;
+        last: number;
+    }>;
+    productsFetching: import("vue").Ref<boolean>;
+    filterProducts: ({ where, page, sort, orFiltersOperator, }: FilterParams) => Promise<void>;
+    productError: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | null>;
+    productStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
+    categories: import("vue").ComputedRef<import("@scayle/storefront-api").Category | import("@scayle/storefront-api").Category[]>;
+    selectedCategory: import("vue").ComputedRef<import("@scayle/storefront-api").Category | undefined>;
+    categoriesFetching: import("vue").Ref<boolean>;
+    categoriesError: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | null>;
+    categoriesStatus: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
     fetchProducts: ({ path, page, perPage, where, sort, pricePromotionKey, cache, orFiltersOperator, }: FilterParams & {
         path: string;
         pricePromotionKey?: string | undefined;