@scayle/storefront-nuxt 7.74.0 → 7.75.1

package/dist/runtime/composables/storefront/useProductsByReferenceKeys.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<'getProductsByReferenceKeys'>>;
-    options: RpcOptions;
+    options: UseRpcOptions<'getProductsByReferenceKeys'>;
+    /** @deprecated use the second argument of the composable to define the key */
     key: string;
 }>;
-export declare function useProductsByReferenceKeys({ params, options, key, }?: Options): Promise<{
-    data: import("vue").Ref<import("@scayle/storefront-api").Product[] | 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 useProductsByReferenceKeys({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'getProductsByReferenceKeys'>;
 export {};

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

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

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

@@ -1,18 +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<'getProductsCount'>>;
-    options: RpcOptions;
+    options: UseRpcOptions<'getProductsCount'>;
+    /** @deprecated use the second argument of the composable to define the key */
     key: string;
 }>;
-export declare function useProductsCount({ params, options, key, }?: Options): Promise<{
-    data: import("vue").Ref<{
-        count: number;
-    } | 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 useProductsCount({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'getProductsCount'>;
 export {};

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

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

package/dist/runtime/composables/storefront/usePromotions.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<'getPromotions'>>;
-    options: RpcOptions;
+    options: UseRpcOptions<'getPromotions'>;
+    /** @deprecated use the second argument of the composable to define the key */
     key: string;
 }>;
-export declare function usePromotions({ 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 usePromotions({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'getPromotions'>;
 export {};

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

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

package/dist/runtime/composables/storefront/usePromotionsByIds.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<'getPromotionsByIds'>>;
-    options: RpcOptions;
+    options: UseRpcOptions<'getPromotionsByIds'>;
+    /** @deprecated use the second argument of the composable to define the key */
     key: string;
 }>;
-export declare function usePromotionsByIds({ 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 usePromotionsByIds({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'getPromotionsByIds'>;
 export {};

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

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

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

@@ -1,13 +1,8 @@
-import type { RpcOptions } from '../core/useRpc';
+import type { UseRpcOptions, UseRpcReturn } from '../core/useRpc';
 type Options = Partial<{
-    options: RpcOptions;
+    options: UseRpcOptions<'getShopConfiguration'>;
+    /** @deprecated use the second argument of the composable to define the key */
     key: string;
 }>;
-export declare function useShopConfiguration({ options, key, }?: Options): Promise<{
-    data: import("vue").Ref<import("@scayle/storefront-api").ShopConfiguration | 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 useShopConfiguration({ options, key: _key, }?: Options, key?: string): UseRpcReturn<'getShopConfiguration'>;
 export {};

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

@@ -1,19 +1,12 @@
 import { useRpc } from "../core/useRpc.mjs";
-export async function useShopConfiguration({
+export function useShopConfiguration({
   options,
-  key = "useShopConfiguration"
-} = {}) {
-  const { data, fetching, fetch, error, status } = await useRpc(
+  key: _key
+} = {}, key) {
+  return useRpc(
     "getShopConfiguration",
-    key,
+    _key ?? key ?? "useShopConfiguration",
     void 0,
     options
   );
-  return {
-    data,
-    fetching,
-    fetch,
-    error,
-    status
-  };
 }

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

@@ -1,13 +1,8 @@
-import type { RpcOptions } from '../core/useRpc';
+import type { UseRpcOptions, UseRpcReturn } from '../core/useRpc';
 type Options = Partial<{
-    options: RpcOptions;
+    options: UseRpcOptions<'getShopUserAddresses'>;
+    /** @deprecated use the second argument of the composable to define the key */
     key: string;
 }>;
-export declare function useUserAddresses({ options, key, }?: Options): Promise<{
-    data: import("vue").Ref<import("@scayle/storefront-core").ShopUserAddress[] | 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 useUserAddresses({ options, key: _key, }?: Options, key?: string): UseRpcReturn<'getShopUserAddresses'>;
 export {};

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

@@ -1,19 +1,12 @@
 import { useRpc } from "../core/useRpc.mjs";
-export async function useUserAddresses({
+export function useUserAddresses({
   options,
-  key = "useUserAddresses"
-} = {}) {
-  const { data, fetching, fetch, error, status } = await useRpc(
+  key: _key
+} = {}, key) {
+  return useRpc(
     "getShopUserAddresses",
-    key,
+    _key ?? key ?? "useUserAddresses",
     void 0,
     options
   );
-  return {
-    data,
-    fetching,
-    fetch,
-    error,
-    status
-  };
 }

package/dist/runtime/composables/storefront/useVariant.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<'getVariantById'>>;
-    options: RpcOptions;
+    options: UseRpcOptions<'getVariantById'>;
+    /** @deprecated use the second argument of the composable to define the key */
     key: string;
 }>;
-export declare function useVariant({ params, options, key, }?: Options): Promise<{
-    data: import("vue").Ref<import("@scayle/storefront-api").VariantDetail[] | 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 useVariant({ params, options, key: _key, }?: Options, key?: string): UseRpcReturn<'getVariantById'>;
 export {};

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

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

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

@@ -4,10 +4,48 @@ type Options = Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getWishlist'>>;
     key: string;
 }>;
-export declare function useWishlist({ params, key, }?: Options): Promise<{
-    data: import("vue").Ref<WishlistResponseData | undefined>;
-    count: import("vue").ComputedRef<number | undefined>;
-    items: import("vue").ComputedRef<WishlistItem[] | undefined>;
+export declare function useWishlist({ params, key, }?: Options): {
+    data: import("vue").Ref<WishlistResponseData>;
+    count: import("vue").ComputedRef<number>;
+    items: import("vue").ComputedRef<WishlistItem[]>;
+    products: import("vue").ComputedRef<Product[]>;
+    addItem: (item: {
+        variantId?: number;
+        productId?: number;
+    }) => Promise<void>;
+    removeItem: (item: {
+        variantId?: number;
+        productId?: number;
+    }) => Promise<void>;
+    replaceItem: (item: {
+        variantId?: number;
+        productId?: number;
+    }, newItem: {
+        variantId?: number;
+        productId?: number;
+    }) => Promise<void>;
+    clear: () => Promise<void>;
+    fetching: import("vue").Ref<boolean>;
+    fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions | undefined) => Promise<void>;
+    toggleItem: (item: {
+        variantId?: number;
+        productId?: number;
+    }) => Promise<void>;
+    findItem: (item: {
+        variantId?: number;
+        productId?: number;
+    }) => WishlistItem | undefined;
+    contains: (item: {
+        variantId: number;
+    } | {
+        productId: number;
+    }) => boolean;
+    error: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | null>;
+    status: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
+} & Promise<{
+    data: import("vue").Ref<WishlistResponseData>;
+    count: import("vue").ComputedRef<number>;
+    items: import("vue").ComputedRef<WishlistItem[]>;
     products: import("vue").ComputedRef<Product[]>;
     addItem: (item: {
         variantId?: number;

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

@@ -3,26 +3,23 @@ import {
   HttpStatusMessage,
   HttpStatusCode
 } 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 { useRpc } from "../core/useRpc.mjs";
+import { extendPromise } from "../../utils/promise.mjs";
 import { useCurrentShop } from "../core/useCurrentShop.mjs";
 import { toValue, toRef } from "#imports";
-export async function useWishlist({
+export function useWishlist({
   params,
   key = "useWishlist"
 } = {}) {
   const nuxtApp = useNuxtApp();
   const shop = useCurrentShop();
-  const {
-    data,
-    pending: fetching,
-    error,
-    refresh: fetch,
-    status
-  } = await useAsyncData(
+  const asyncData = useRpc(
+    "getWishlist",
     key,
-    () => rpcCall(nuxtApp, "getWishlist", toValue(shop))(toValue(params)),
+    params,
     {
       server: false,
       // TODO: In some cases it might be ok to fetch on server
@@ -30,10 +27,16 @@ export async function useWishlist({
       dedupe: "defer",
       getCachedData: (key2) => {
         return toValue(nuxtApp._asyncData[key2]?.data) ?? void 0;
-      },
-      default: () => void 0
+      }
     }
   );
+  const {
+    data,
+    pending: fetching,
+    error,
+    refresh: fetch,
+    status
+  } = asyncData;
   const addItem = async (item) => {
     data.value = await rpcCall(
       nuxtApp,
@@ -111,7 +114,7 @@ export async function useWishlist({
   const products = computed(() => {
     return items.value?.map((item) => item.product) || [];
   });
-  return {
+  return extendPromise(asyncData.then(() => ({})), {
     data,
     count,
     items,
@@ -127,5 +130,5 @@ export async function useWishlist({
     contains,
     error,
     status
-  };
+  });
 }

package/dist/runtime/log.mjs

@@ -37,7 +37,7 @@ export class Log {
       try {
         this._handler({ level, message, data, space: this._space });
       } catch (e) {
-        console.error(`Error writing log message: ${e}`);
+        console.error(`Error writing log message: "${message}" -- ${e}`);
       }
     } else {
       const logFunc = console[level] || console.log;

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

@@ -0,0 +1,9 @@
+/**
+ * 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
+ */
+export declare function extendPromise<T extends object, U>(promise: T & Promise<T>, source: U): T & U & Promise<T & U>;

package/dist/runtime/utils/promise.mjs

@@ -0,0 +1,12 @@
+export 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));
+}