@scayle/storefront-nuxt 7.74.0 → 7.75.1

package/CHANGELOG.md

@@ -1,5 +1,54 @@
 # @scayle/storefront-nuxt
 
+## 7.75.1
+
+### Patch Changes
+
+- Add `immediate` option to `useUser` and deprecate `autoFetch`
+- Log warning when deprecated `autoFetch` option is used
+
+## 7.75.0
+
+### Minor Changes
+
+- Configure `keyedComposables` to automatically create keys for `useRpc` wrapping composables instead of relying on hardcoded defaults
+- Export the `extendPromise` util
+- Restore the `useAsyncData` implementation of `useRpc`
+
+  Originally, `useRpc` was based on `useAsyncData` but in order to fix an issue with wishlists, we restricted the API and changed it to a rough emulation of `useAsyncData`. Because this emulation was similar, but not the same as `useAsyncData` it caused additional confusion. This change brings back the `useAsyncData` implementation.
+
+  For developers, this means that `useRpc` will behave in the same manner as `useAsyncData`, be subject to the same restrictions and allow the same options.
+
+  This also means that `useRpc` is now optionally awaitable. `const { data } = await useRpc()` now works as well as `const { data } = useRpc()`. The difference is that the former will wait for the data to load, while the latter will initially be set to the default value.
+
+  Composables which are simply wrappers around `useRpc` also inherit this new behavior. They accept the same options as `useAsyncData`, return the same properties (and possibly some additional ones) and are optionally awaitable.
+
+  This includes the following composables:
+
+  - `useBrand`
+  - `useBrands`
+  - `useCategories`
+  - `useCategoryById`
+  - `useCategoryByPath`
+  - `useCurrentPromotions`
+  - `useFilters`
+  - `useNavigationTree`
+  - `useNavigationTrees`
+  - `useProduct`
+  - `useProducts`
+  - `useProductsByIds`
+  - `useProductsByReferenceKeys`
+  - `useProductsCount`
+  - `usePromotions`
+  - `usePromotionsByIds`
+  - `useShopConfiguration`
+  - `useUserAddresses`
+  - `useVariant`
+
+### Patch Changes
+
+- It is no longer mandatory to `await` calls to `useFacet`, `useUser`, `useWishlist` and `useBasket`
+
 ## 7.74.0
 
 ### Minor Changes
@@ -16,7 +65,7 @@
 
 ### Minor Changes
 
-- Renamed ModuleOptions to ModuleBaseOptions to differentiate it from other ModuleOptions used in different modules.
+- Breaking: Renamed ModuleOptions to ModuleBaseOptions to differentiate it from other ModuleOptions used in different modules.
 
 ### Patch Changes
 

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-export { d as AdditionalShopConfig, A as AppKeys, B as BapiConfig, h as CheckoutEvent, C as CheckoutShopConfig, M as ModuleBaseOptions, i as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, a as SessionConfig, e as ShopConfig, f as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, g as StorefrontConfig } from './shared/storefront-nuxt.db7a2f93.mjs';
+export { d as AdditionalShopConfig, A as AppKeys, B as BapiConfig, h as CheckoutEvent, C as CheckoutShopConfig, M as ModuleBaseOptions, i as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, a as SessionConfig, e as ShopConfig, f as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, g as StorefrontConfig } from './shared/storefront-nuxt.257df9a6.mjs';
 export { rpcCall } from './rpc.mjs';
 export * from '@scayle/storefront-core';
 export { LogLevel } from '@scayle/storefront-core';
@@ -9,6 +9,16 @@ import 'unstorage';
 import 'zod';
 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 {
 }
 declare module '@scayle/storefront-core' {
@@ -16,4 +26,4 @@ declare module '@scayle/storefront-core' {
     }
 }
 
-export type { RpcMethodsStorefront };
+export { type RpcMethodsStorefront, extendPromise };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { d as AdditionalShopConfig, A as AppKeys, B as BapiConfig, h as CheckoutEvent, C as CheckoutShopConfig, M as ModuleBaseOptions, i as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, a as SessionConfig, e as ShopConfig, f as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, g as StorefrontConfig } from './shared/storefront-nuxt.db7a2f93.js';
+export { d as AdditionalShopConfig, A as AppKeys, B as BapiConfig, h as CheckoutEvent, C as CheckoutShopConfig, M as ModuleBaseOptions, i as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, a as SessionConfig, e as ShopConfig, f as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, g as StorefrontConfig } from './shared/storefront-nuxt.257df9a6.js';
 export { rpcCall } from './rpc.js';
 export * from '@scayle/storefront-core';
 export { LogLevel } from '@scayle/storefront-core';
@@ -9,6 +9,16 @@ import 'unstorage';
 import 'zod';
 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 {
 }
 declare module '@scayle/storefront-core' {
@@ -16,4 +26,4 @@ declare module '@scayle/storefront-core' {
     }
 }
 
-export type { RpcMethodsStorefront };
+export { type RpcMethodsStorefront, extendPromise };

package/dist/index.mjs

@@ -1,3 +1,18 @@
 export { rpcCall } from './rpc.mjs';
 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,6 +1,6 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { M as ModuleBaseOptions } from './shared/storefront-nuxt.db7a2f93.mjs';
-export { d as AdditionalShopConfig, A as AppKeys, B as BapiConfig, h as CheckoutEvent, C as CheckoutShopConfig, i as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, a as SessionConfig, e as ShopConfig, f as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, g as StorefrontConfig } from './shared/storefront-nuxt.db7a2f93.mjs';
+import { M as ModuleBaseOptions } from './shared/storefront-nuxt.257df9a6.mjs';
+export { d as AdditionalShopConfig, A as AppKeys, B as BapiConfig, h as CheckoutEvent, C as CheckoutShopConfig, i as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, a as SessionConfig, e as ShopConfig, f as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, g as StorefrontConfig } from './shared/storefront-nuxt.257df9a6.mjs';
 export { LogLevel } from '@scayle/storefront-core';
 import '@scayle/unstorage-compression-driver';
 import 'unstorage';

package/dist/module.d.ts

@@ -1,6 +1,6 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { M as ModuleBaseOptions } from './shared/storefront-nuxt.db7a2f93.js';
-export { d as AdditionalShopConfig, A as AppKeys, B as BapiConfig, h as CheckoutEvent, C as CheckoutShopConfig, i as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, a as SessionConfig, e as ShopConfig, f as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, g as StorefrontConfig } from './shared/storefront-nuxt.db7a2f93.js';
+import { M as ModuleBaseOptions } from './shared/storefront-nuxt.257df9a6.js';
+export { d as AdditionalShopConfig, A as AppKeys, B as BapiConfig, h as CheckoutEvent, C as CheckoutShopConfig, i as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, a as SessionConfig, e as ShopConfig, f as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, g as StorefrontConfig } from './shared/storefront-nuxt.257df9a6.js';
 export { LogLevel } from '@scayle/storefront-core';
 import '@scayle/unstorage-compression-driver';
 import 'unstorage';

package/dist/module.json

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

package/dist/module.mjs

@@ -64,7 +64,7 @@ export default {
 }`;
 }
 const PACKAGE_NAME = "@scayle/storefront-nuxt";
-const PACKAGE_VERSION = "7.73.0";
+const PACKAGE_VERSION = "7.75.0";
 const logger = createConsola({
   fancy: true,
   formatOptions: {
@@ -315,6 +315,37 @@ Missing RPC Overrides: ${Array.from(overridenRPCMethodNames).map((name) => `'${n
     addImportsDir(resolve("runtime/composables/storefront"));
     addImportsDir(resolve("runtime/composables/core"));
     addImportsDir(resolve("runtime/utils"));
+    const keyedComposables = [
+      "useBrand",
+      "useBrands",
+      "useCategories",
+      "useCategoryById",
+      "useCategoryByPath",
+      "useCurrentPromotions",
+      "useFacet",
+      "useFilters",
+      "useIDP",
+      "useNavigationTree",
+      "useNavigationTrees",
+      "useOrder",
+      "useOrderConfirmation",
+      "useProduct",
+      "useProducts",
+      "useProductsByIds",
+      "useProductsByReferenceKeys",
+      "useProductsCount",
+      "usePromotions",
+      "usePromotionsByIds",
+      "useShopConfiguration",
+      "useUserAddresses",
+      "useVariant"
+    ];
+    nuxt.options.optimization.keyedComposables.push(
+      ...keyedComposables.map((name) => ({
+        name,
+        argumentLength: 2
+      }))
+    );
     nuxt.options.build.transpile = [
       ...nuxt.options.build?.transpile || [],
       PACKAGE_NAME,

package/dist/rpc.d.mts

@@ -1,6 +1,6 @@
 import { RpcMethodName, RpcMethodParameters, RpcMethodReturnType, RpcContext } from '@scayle/storefront-core';
 import { NuxtApp } from 'nuxt/app';
-import { P as PublicShopConfig } from './shared/storefront-nuxt.db7a2f93.mjs';
+import { P as PublicShopConfig } from './shared/storefront-nuxt.257df9a6.mjs';
 import '@nuxt/schema';
 import '@scayle/unstorage-compression-driver';
 import 'unstorage';

package/dist/rpc.d.ts

@@ -1,6 +1,6 @@
 import { RpcMethodName, RpcMethodParameters, RpcMethodReturnType, RpcContext } from '@scayle/storefront-core';
 import { NuxtApp } from 'nuxt/app';
-import { P as PublicShopConfig } from './shared/storefront-nuxt.db7a2f93.js';
+import { P as PublicShopConfig } from './shared/storefront-nuxt.257df9a6.js';
 import '@nuxt/schema';
 import '@scayle/unstorage-compression-driver';
 import 'unstorage';

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

@@ -1,13 +1,13 @@
 import { type MaybeRefOrGetter } from 'vue';
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-export declare function useIDP(params?: MaybeRefOrGetter<RpcMethodParameters<'getExternalIdpRedirect'>>): Promise<{
+export declare function useIDP(params?: MaybeRefOrGetter<RpcMethodParameters<'getExternalIdpRedirect'>>, key?: string): Promise<{
     data: import("vue").Ref<{
         [k: string]: string;
-    } | 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>;
+    fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions | undefined) => Promise<void>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | null>;
+    status: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
     handleIDPLoginCallback: (params: string | {
         code: string;
     }) => Promise<{

package/dist/runtime/composables/core/useIDP.mjs

@@ -3,12 +3,12 @@ import { useRpc } from "../core/useRpc.mjs";
 import { rpcCall } from "./../../rpc/rpcCall.mjs";
 import { useCurrentShop } from "./useCurrentShop.mjs";
 import { toValue } from "#imports";
-export async function useIDP(params = {}) {
+export async function useIDP(params = {}, key) {
   const nuxtApp = useNuxtApp();
   const shop = useCurrentShop();
   const { data, fetching, fetch, error, status } = await useRpc(
     "getExternalIdpRedirect",
-    `getExternalIdpRedirect-${JSON.stringify(toValue(params))}`,
+    key ?? "useIDP",
     params
   );
   const handleIDPLoginCallback = rpcCall(

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

@@ -1,18 +1,47 @@
 import type { RpcContext, RpcMethodName, RpcMethodParameters, RpcMethodReturnType } from '@scayle/storefront-core';
-import type { AsyncDataOptions, NuxtError } from 'nuxt/app';
-import { type MaybeRefOrGetter } from '#imports';
+import type { AsyncDataOptions } from 'nuxt/app';
+import { useAsyncData } from 'nuxt/app';
+import type { MaybeRefOrGetter } from '#imports';
 type KeysOf<T> = Array<T extends T ? (keyof T extends string ? keyof T : never) : never>;
 export type RpcAsyncDataOptions<TResult> = AsyncDataOptions<TResult, TResult, KeysOf<TResult>, TResult>;
 export interface RpcOptions {
+    /** @deprecated use immediate instead */
     autoFetch?: boolean;
     lazy?: boolean;
 }
+export type UseRpcOptions<N extends RpcMethodName> = RpcOptions & RpcAsyncDataOptions<Exclude<Awaited<RpcMethodReturnType<N>>, Response>>;
+export type UseRpcReturn<N extends RpcMethodName> = ExtendedAsyncData<Exclude<Awaited<RpcMethodReturnType<N>>, Response>>;
 export type Status = 'idle' | 'pending' | 'success' | 'error';
-export declare function useRpc<N extends RpcMethodName, P extends RpcMethodParameters<N>, TResult extends Exclude<Awaited<RpcMethodReturnType<N>>, Response>, TParams = P extends RpcContext ? undefined : P>(method: N, key: string, params?: MaybeRefOrGetter<TParams>, options?: RpcOptions): Promise<{
-    data: import("vue").Ref<TResult | undefined>;
-    fetching: import("vue").Ref<boolean>;
-    fetch: () => Promise<void>;
-    error: import("vue").Ref<NuxtError<unknown> | undefined>;
-    status: import("vue").Ref<Status>;
-}>;
+type AsyncData<T> = ReturnType<typeof useAsyncData<T>>;
+type AwaitedAsyncData<T> = Awaited<AsyncData<T>>;
+type _ExtendedAsyncData<T> = AwaitedAsyncData<T> & {
+    fetching: AwaitedAsyncData<T>['pending'];
+    fetch: AwaitedAsyncData<T>['refresh'];
+};
+export type ExtendedAsyncData<T> = _ExtendedAsyncData<T> & Promise<_ExtendedAsyncData<T>>;
+/**
+ * `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}
+ */
+export declare function useRpc<N extends RpcMethodName, P extends RpcMethodParameters<N>, TResult extends Exclude<Awaited<RpcMethodReturnType<N>>, Response>, TParams = P extends RpcContext ? undefined : P>(method: N, key: string, params?: MaybeRefOrGetter<TParams>, options?: RpcAsyncDataOptions<TResult> & RpcOptions): ExtendedAsyncData<TResult>;
 export {};

package/dist/runtime/composables/core/useRpc.mjs

@@ -1,9 +1,9 @@
 import { unwrap } from "@scayle/storefront-core/dist/utils/response";
-import { useNuxtApp, useState, createError } from "nuxt/app";
+import { useNuxtApp, useAsyncData } from "nuxt/app";
 import { useCoreLog } from "../useCoreLog.mjs";
-import { resolveError } from "../../error/handler.mjs";
 import { useCurrentShop } from "./useCurrentShop.mjs";
-import { toValue } from "#imports";
+import { extendPromise } from "../../utils/promise.mjs";
+import { toValue, computed, isRef } from "#imports";
 function getFetch(nuxtApp, log) {
   const fetch = nuxtApp.ssrContext?.event.$fetch ?? $fetch;
   if (nuxtApp.ssrContext?.event && !nuxtApp.ssrContext?.event.$fetch) {
@@ -11,36 +11,25 @@ function getFetch(nuxtApp, log) {
   }
   return fetch;
 }
-const handleError = (error) => {
-  const data = resolveError(error);
-  return createError(data);
-};
-export async function useRpc(method, key, params, options = { autoFetch: true, lazy: false }) {
+export function useRpc(method, key, params, options) {
   const currentShop = useCurrentShop();
   const log = useCoreLog("rpc");
   const nuxtApp = useNuxtApp();
-  const isAutoFetchEnabled = options?.autoFetch ?? true;
-  log.debug(`useRpc: ${method}`);
-  const keyPrefix = `${method}-${key}`;
-  const data = useState(
-    `${keyPrefix}-data`,
-    () => void 0
-  );
-  const fetching = useState(`${keyPrefix}-fetching`, () => false);
-  const error = useState(
-    `${keyPrefix}-error`,
-    () => void 0
-  );
-  const status = useState(`${keyPrefix}-status`, () => "idle");
-  const fetch = async () => {
-    try {
-      status.value = "pending";
-      fetching.value = true;
-      error.value = void 0;
+  if (options && options.autoFetch !== void 0) {
+    log.warn("autoFetch is disabled; use immediate instead");
+    if (options.immediate === void 0) {
+      options.immediate = options.autoFetch;
+    } else {
+      log.warn("autoFetch will be ignored because immediate was specified");
+    }
+  }
+  const asyncData = useAsyncData(
+    key,
+    async () => {
       const apiBasePath = currentShop.value?.apiBasePath ?? "/api";
-      const fetch2 = getFetch(nuxtApp, log);
-      data.value = await unwrap(
-        await fetch2(`/rpc/${method}`, {
+      const fetch = getFetch(nuxtApp, log);
+      return await unwrap(
+        await fetch(`/rpc/${method}`, {
           // @ts-expect-error Type '"POST"' is not assignable to type 'AvailableRouterMethod<`/rpc/${N}`> | Uppercase<AvailableRouterMethod<`/rpc/${N}`>> | undefined'.ts(2322)
           method: "POST",
           body: {
@@ -52,25 +41,16 @@ export async function useRpc(method, key, params, options = { autoFetch: true, l
           }
         })
       );
-    } catch (e) {
-      error.value = handleError(e);
-    } finally {
-      fetching.value = false;
-      status.value = error.value ? "error" : "success";
+    },
+    {
+      ...isRef(params) ? { watch: [params] } : {},
+      ...options
     }
-  };
-  if (isAutoFetchEnabled && status.value === "idle") {
-    if (import.meta.server) {
-      await fetch();
-    } else {
-      options.lazy ? fetch() : await fetch();
-    }
-  }
-  return {
-    data,
-    fetching,
-    fetch,
-    error,
-    status
-  };
+  );
+  return extendPromise(asyncData, {
+    /** @deprecated - use refresh instead */
+    fetch: asyncData.refresh,
+    /** @deprecated - use `status.value === 'pending'´ instead */
+    fetching: computed(() => asyncData.status.value === "pending")
+  });
 }

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

@@ -1,16 +1,31 @@
-import type { ShopUser, UpdatePasswordParams, UseUserParams } from '@scayle/storefront-core';
-export type ExtendedUseUserParams = UseUserParams & {
+import type { ShopUser, UpdatePasswordParams } from '@scayle/storefront-core';
+export type ExtendedUseUserParams = {
+    key?: string;
+    /** @deprecated use immediate instead */
+    autoFetch?: boolean;
+    immediate?: boolean;
     lazy?: boolean;
 };
-export declare function useUser({ autoFetch, lazy, key, }?: ExtendedUseUserParams): Promise<{
+export declare function useUser(options?: ExtendedUseUserParams): {
     user: import("vue").ComputedRef<ShopUser | undefined>;
     isLoggedIn: import("vue").ComputedRef<boolean>;
     customerType: import("vue").ComputedRef<"guest" | "new" | "existing">;
     fetching: import("vue").Ref<boolean>;
-    fetch: () => Promise<void>;
+    fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions | undefined) => Promise<void>;
     forceRefresh: () => Promise<void>;
     updateUser: (payload: Partial<ShopUser>) => Promise<void>;
     updatePassword: (payload: UpdatePasswordParams) => Promise<void>;
-    error: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | undefined>;
-    status: import("vue").Ref<import("./useRpc").Status>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | null>;
+    status: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
+} & Promise<{
+    user: import("vue").ComputedRef<ShopUser | undefined>;
+    isLoggedIn: import("vue").ComputedRef<boolean>;
+    customerType: import("vue").ComputedRef<"guest" | "new" | "existing">;
+    fetching: import("vue").Ref<boolean>;
+    fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions | undefined) => Promise<void>;
+    forceRefresh: () => Promise<void>;
+    updateUser: (payload: Partial<ShopUser>) => Promise<void>;
+    updatePassword: (payload: UpdatePasswordParams) => Promise<void>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | null>;
+    status: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
 }>;

package/dist/runtime/composables/core/useUser.mjs

@@ -2,26 +2,42 @@ import { useNuxtApp } from "nuxt/app";
 import { computed } from "vue";
 import { rpcCall } from "../../rpc/rpcCall.mjs";
 import { useCoreLog } from "../useCoreLog.mjs";
+import { extendPromise } from "../../utils/promise.mjs";
 import { useRpc } from "./useRpc.mjs";
 import { useCurrentShop } from "./useCurrentShop.mjs";
 import { toValue } from "#imports";
-export async function useUser({
-  autoFetch = true,
-  lazy = false,
-  key = "useUser"
-} = {}) {
+export function useUser(options = {}) {
   const nuxtApp = useNuxtApp();
   const shop = useCurrentShop();
   const log = useCoreLog("useUser");
-  const { data, fetching, fetch, error, status } = await useRpc(
+  if (options && options.autoFetch !== void 0) {
+    log.warn("autoFetch is disabled; use immediate instead");
+    if (options.immediate === void 0) {
+      options.immediate = options.autoFetch;
+    } else {
+      log.warn("autoFetch will be ignored because immediate was specified");
+    }
+  }
+  const {
+    immediate = true,
+    lazy = false,
+    key = "useUser"
+  } = options;
+  const asyncDataPromise = useRpc(
     "getUser",
     key,
     void 0,
     {
-      autoFetch,
-      lazy
+      immediate,
+      lazy,
+      server: false,
+      dedupe: "defer",
+      getCachedData: (key2) => {
+        return toValue(nuxtApp._asyncData[key2]?.data) ?? void 0;
+      }
     }
   );
+  const { data, fetching, fetch, error, status } = asyncDataPromise;
   const updateUser = async (payload) => {
     log.debug("Update user");
     data.value = await rpcCall(
@@ -53,7 +69,7 @@ export async function useUser({
     log.debug("Refresh user");
     data.value = await rpcCall(nuxtApp, "refreshUser", toValue(shop))();
   };
-  return {
+  return extendPromise(asyncDataPromise.then(() => ({})), {
     user,
     isLoggedIn,
     customerType,
@@ -64,5 +80,5 @@ export async function useUser({
     updatePassword,
     error,
     status
-  };
+  });
 }

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

@@ -5,18 +5,79 @@ type UseBasketOptions = Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getBasket'>>;
     key: string;
 }>;
-export declare function useBasket({ params, key, }?: UseBasketOptions): Promise<{
-    data: import("vue").Ref<BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant> | undefined>;
-    items: import("vue").ComputedRef<import("@scayle/storefront-api").BasketItem<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>[] | undefined>;
-    cost: import("vue").ComputedRef<import("@scayle/storefront-api").BasketTotalPrice | undefined>;
-    key: import("vue").ComputedRef<import("@scayle/storefront-api").BasketKey | undefined>;
-    packages: import("vue").ComputedRef<import("@scayle/storefront-api").BasketPackageInformation[] | undefined>;
+export declare function useBasket({ params, key, }?: UseBasketOptions): import("nuxt/dist/app/composables/asyncData")._AsyncData<BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>, import("nuxt/app").NuxtError<unknown> | null> & {
+    fetching: import("vue").Ref<boolean>;
+    fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions | undefined) => Promise<void>;
+} & {
+    data: import("vue").Ref<BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>>;
+    items: import("vue").ComputedRef<import("@scayle/storefront-api").BasketItem<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>[]>;
+    cost: import("vue").ComputedRef<import("@scayle/storefront-api").BasketTotalPrice>;
+    key: import("vue").ComputedRef<import("@scayle/storefront-api").BasketKey>;
+    packages: import("vue").ComputedRef<import("@scayle/storefront-api").BasketPackageInformation[]>;
+    shippingDates: import("vue").ComputedRef<(string | null)[] | undefined>;
+    isEmpty: import("vue").ComputedRef<boolean>;
+    fetching: import("vue").Ref<boolean>;
+    fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions | undefined) => Promise<void>;
+    count: import("vue").ComputedRef<number>;
+    countWithoutSoldOutItems: import("vue").ComputedRef<number>;
+    addItem: ({ variantId, promotionId, quantity, existingItemHandling, displayData, customData, itemGroup, }: AddOrUpdateItemType & {
+        existingItemHandling?: ExistingItemHandling;
+    }) => Promise<void>;
+    addItems: (items: AddOrUpdateItemType[], existingItemHandling?: 1) => Promise<void>;
+    removeItem: (item: {
+        variantId: number;
+    }) => Promise<void>;
+    clear: () => Promise<void>;
+    contains: (item: {
+        variantId: number;
+    } | {
+        productId: number;
+    }) => boolean;
+    products: import("vue").ComputedRef<import("@scayle/storefront-api").Product[]>;
+    findItem: (item: {
+        variantId: number;
+    } | {
+        productId: number;
+    }) => import("@scayle/storefront-api").BasketItem<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant> | undefined;
+    generateBasketKey: ({ keyTemplate, hashAlgorithm, shopId, userId, log, }: {
+        keyTemplate: string;
+        hashAlgorithm: import("@scayle/storefront-core").HashAlgorithm;
+        shopId: string;
+        userId: string;
+        log?: import("@scayle/storefront-core").Log | undefined;
+    }) => Promise<string>;
+    mergeBaskets: (args: {
+        fromBasketKey: string;
+        toBasketKey: string;
+    }) => Promise<{
+        type: "failure";
+        statusCode: number;
+        basket: BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>;
+    } | {
+        readonly type: "success";
+        readonly basket: BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>;
+    } | {
+        readonly type: "failure";
+        readonly basket: BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>;
+        readonly errors: import("@scayle/storefront-api").AddOrUpdateItemError[];
+    } | undefined>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError<unknown> | null>;
+    status: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
+} & Promise<import("nuxt/dist/app/composables/asyncData")._AsyncData<BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>, import("nuxt/app").NuxtError<unknown> | null> & {
+    fetching: import("vue").Ref<boolean>;
+    fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions | undefined) => Promise<void>;
+} & {
+    data: import("vue").Ref<BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>>;
+    items: import("vue").ComputedRef<import("@scayle/storefront-api").BasketItem<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>[]>;
+    cost: import("vue").ComputedRef<import("@scayle/storefront-api").BasketTotalPrice>;
+    key: import("vue").ComputedRef<import("@scayle/storefront-api").BasketKey>;
+    packages: import("vue").ComputedRef<import("@scayle/storefront-api").BasketPackageInformation[]>;
     shippingDates: import("vue").ComputedRef<(string | null)[] | undefined>;
     isEmpty: import("vue").ComputedRef<boolean>;
     fetching: import("vue").Ref<boolean>;
     fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions | undefined) => Promise<void>;
-    count: import("vue").ComputedRef<number | undefined>;
-    countWithoutSoldOutItems: import("vue").ComputedRef<number | undefined>;
+    count: import("vue").ComputedRef<number>;
+    countWithoutSoldOutItems: import("vue").ComputedRef<number>;
     addItem: ({ variantId, promotionId, quantity, existingItemHandling, displayData, customData, itemGroup, }: AddOrUpdateItemType & {
         existingItemHandling?: ExistingItemHandling;
     }) => Promise<void>;