@scayle/storefront-nuxt 7.75.0 → 7.76.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @scayle/storefront-nuxt
 
+## 7.76.0
+
+### Minor Changes
+
+- `useOrder` `useOrderConfirmation` and `useIDP` are now optionally awaitable
+
+## 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

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@scayle/storefront-nuxt",
-  "version": "7.74.0",
+  "version": "7.75.1",
   "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.74.0";
+const PACKAGE_VERSION = "7.75.1";
 const logger = createConsola({
   fancy: true,
   formatOptions: {

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

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

@@ -1,12 +1,13 @@
 import { useNuxtApp } from "nuxt/app";
 import { useRpc } from "../core/useRpc.mjs";
+import { extendPromise } from "../../utils/promise.mjs";
 import { rpcCall } from "./../../rpc/rpcCall.mjs";
 import { useCurrentShop } from "./useCurrentShop.mjs";
 import { toValue } from "#imports";
-export async function useIDP(params = {}, key) {
+export function useIDP(params = {}, key) {
   const nuxtApp = useNuxtApp();
   const shop = useCurrentShop();
-  const { data, fetching, fetch, error, status } = await useRpc(
+  const useRpcPromise = useRpc(
     "getExternalIdpRedirect",
     key ?? "useIDP",
     params
@@ -16,13 +17,8 @@ export async function useIDP(params = {}, key) {
     "handleIDPLoginCallback",
     toValue(shop)
   );
-  return {
-    data,
-    fetching,
-    fetch,
-    error,
-    status,
+  return extendPromise(useRpcPromise, {
     // TODO: Deprecate the property here and remove it with the next major release
     handleIDPLoginCallback
-  };
+  });
 }

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

@@ -15,8 +15,13 @@ export function useRpc(method, key, params, options) {
   const currentShop = useCurrentShop();
   const log = useCoreLog("rpc");
   const nuxtApp = useNuxtApp();
-  if (options && options.autoFetch !== void 0 && options.immediate === void 0) {
-    options.immediate = options.autoFetch;
+  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,

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

@@ -1,8 +1,12 @@
-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): {
+export declare function useUser(options?: ExtendedUseUserParams): {
     user: import("vue").ComputedRef<ShopUser | undefined>;
     isLoggedIn: import("vue").ComputedRef<boolean>;
     customerType: import("vue").ComputedRef<"guest" | "new" | "existing">;

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

@@ -6,20 +6,29 @@ import { extendPromise } from "../../utils/promise.mjs";
 import { useRpc } from "./useRpc.mjs";
 import { useCurrentShop } from "./useCurrentShop.mjs";
 import { toValue } from "#imports";
-export function useUser({
-  autoFetch = true,
-  lazy = false,
-  key = "useUser"
-} = {}) {
+export function useUser(options = {}) {
   const nuxtApp = useNuxtApp();
   const shop = useCurrentShop();
   const log = useCoreLog("useUser");
+  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,
+      immediate,
       lazy,
       server: false,
       dedupe: "defer",

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

@@ -38,7 +38,7 @@ export function useFacet({
       path: currentPath.value,
       includeHidden: params.with?.product?.categories?.includeHidden || void 0
     }),
-    options: { autoFetch: false },
+    options: { immediate: false },
     key: `${key}-categories`
   });
   const productsPromise = useProducts({
@@ -55,7 +55,7 @@ export function useFacet({
       cache: currentCacheParams.value,
       orFiltersOperator: currentOrFiltersOperator.value
     }),
-    options: { autoFetch: false },
+    options: { immediate: false },
     key: `${key}-products`
   });
   const productsCountPromise = useProductsCount({
@@ -67,7 +67,7 @@ export function useFacet({
       where: productCountWhere.value,
       orFiltersOperator: currentOrFiltersOperator.value
     }),
-    options: { autoFetch: false },
+    options: { immediate: false },
     key: `${key}-productCount`
   });
   const filtersPromise = useFilters({
@@ -79,7 +79,7 @@ export function useFacet({
       where: currentWhereCondition.value,
       orFiltersOperator: currentOrFiltersOperator.value
     }),
-    options: { autoFetch: false },
+    options: { immediate: false },
     key: `${key}-filters`
   });
   const {

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

@@ -11,7 +11,10 @@ export declare function useOrder<P = {
     [k: string]: unknown;
 }, V = {
     [k: string]: unknown;
-}>({ params, options, key: _key }?: Options, key?: string): Promise<{
+}>({ params, options, key: _key }?: Options, key?: string): import("nuxt/dist/app/composables/asyncData")._AsyncData<Order, import("nuxt/app").NuxtError<unknown> | null> & {
+    fetching: import("vue").Ref<boolean>;
+    fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions | undefined) => Promise<void>;
+} & {
     data: Ref<Order & {
         items?: ({
             id?: number | undefined;
@@ -82,9 +85,79 @@ export declare function useOrder<P = {
             variant: V;
         })[] | undefined;
     }>;
+} & Promise<import("nuxt/dist/app/composables/asyncData")._AsyncData<Order, import("nuxt/app").NuxtError<unknown> | null> & {
     fetching: import("vue").Ref<boolean>;
     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>;
+} & {
+    data: Ref<Order & {
+        items?: ({
+            id?: number | undefined;
+            availableQuantity?: number | undefined;
+            currency?: string | undefined;
+            customData?: {
+                [k: string]: unknown;
+            } | undefined;
+            deliveryForecast?: import("@scayle/storefront-core").DeliveryForecastFromWarehouse | undefined;
+            isManuallyReturnedByCci?: boolean | undefined;
+            itemGroup?: {
+                id: string;
+                isMainItem: boolean;
+                isRequired: boolean;
+            } | null | undefined;
+            key: string;
+            lowestPriorPrice?: {
+                relativeDifferenceToPrice: number;
+                withTax: number;
+            } | null | undefined;
+            merchant?: {
+                [k: string]: unknown;
+                id: number;
+            } | undefined;
+            packageId: number;
+            price: {
+                appliedReductions?: {
+                    amount: {
+                        absoluteWithTax: number;
+                        relative: number;
+                    };
+                    category: "voucher" | "sale" | "campaign";
+                    code?: string | undefined;
+                    type: "relative" | "absolute";
+                }[] | undefined;
+                overrideWithoutTax?: number | undefined;
+                overrideWithTax?: number | undefined;
+                reference?: {
+                    size?: string | undefined;
+                    unit?: string | undefined;
+                    withTax?: number | undefined;
+                } | undefined;
+                tax: {
+                    [k: string]: {
+                        amount: number;
+                        rate: number;
+                    };
+                };
+                undiscountedWithOutTax?: number | undefined;
+                undiscountedWithTax?: number | undefined;
+                withoutTax: number;
+                withTax: number;
+            };
+            product: {
+                [k: string]: unknown;
+            };
+            reservationKey?: string | undefined;
+            status: "available" | "unavailable" | "cancelled" | "delivered" | "returned";
+            variant: {
+                [k: string]: unknown;
+            };
+            warehouseId?: import("@scayle/storefront-core").PickingWarehouseId | undefined;
+            warehousePackageGroupId?: import("@scayle/storefront-core").WarehousePackageReference | undefined;
+            createdAt: string;
+            updatedAt: string;
+        } & {
+            product: P;
+            variant: V;
+        })[] | undefined;
+    }>;
 }>;
 export {};

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

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

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

@@ -11,7 +11,10 @@ export declare function useOrderConfirmation<P = {
     [k: string]: unknown;
 }, V = {
     [k: string]: unknown;
-}>({ params, options, key: _key }?: Options, key?: string): Promise<{
+}>({ params, options, key: _key }?: Options, key?: string): import("nuxt/dist/app/composables/asyncData")._AsyncData<Order | undefined, import("nuxt/app").NuxtError<unknown> | null> & {
+    fetching: import("vue").Ref<boolean>;
+    fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions | undefined) => Promise<void>;
+} & {
     data: Ref<Order & {
         items?: ({
             id?: number | undefined;
@@ -82,9 +85,79 @@ export declare function useOrderConfirmation<P = {
             variant: V;
         })[] | undefined;
     }>;
+} & Promise<import("nuxt/dist/app/composables/asyncData")._AsyncData<Order | undefined, import("nuxt/app").NuxtError<unknown> | null> & {
     fetching: import("vue").Ref<boolean>;
     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>;
+} & {
+    data: Ref<Order & {
+        items?: ({
+            id?: number | undefined;
+            availableQuantity?: number | undefined;
+            currency?: string | undefined;
+            customData?: {
+                [k: string]: unknown;
+            } | undefined;
+            deliveryForecast?: import("@scayle/storefront-core").DeliveryForecastFromWarehouse | undefined;
+            isManuallyReturnedByCci?: boolean | undefined;
+            itemGroup?: {
+                id: string;
+                isMainItem: boolean;
+                isRequired: boolean;
+            } | null | undefined;
+            key: string;
+            lowestPriorPrice?: {
+                relativeDifferenceToPrice: number;
+                withTax: number;
+            } | null | undefined;
+            merchant?: {
+                [k: string]: unknown;
+                id: number;
+            } | undefined;
+            packageId: number;
+            price: {
+                appliedReductions?: {
+                    amount: {
+                        absoluteWithTax: number;
+                        relative: number;
+                    };
+                    category: "voucher" | "sale" | "campaign";
+                    code?: string | undefined;
+                    type: "relative" | "absolute";
+                }[] | undefined;
+                overrideWithoutTax?: number | undefined;
+                overrideWithTax?: number | undefined;
+                reference?: {
+                    size?: string | undefined;
+                    unit?: string | undefined;
+                    withTax?: number | undefined;
+                } | undefined;
+                tax: {
+                    [k: string]: {
+                        amount: number;
+                        rate: number;
+                    };
+                };
+                undiscountedWithOutTax?: number | undefined;
+                undiscountedWithTax?: number | undefined;
+                withoutTax: number;
+                withTax: number;
+            };
+            product: {
+                [k: string]: unknown;
+            };
+            reservationKey?: string | undefined;
+            status: "available" | "unavailable" | "cancelled" | "delivered" | "returned";
+            variant: {
+                [k: string]: unknown;
+            };
+            warehouseId?: import("@scayle/storefront-core").PickingWarehouseId | undefined;
+            warehousePackageGroupId?: import("@scayle/storefront-core").WarehousePackageReference | undefined;
+            createdAt: string;
+            updatedAt: string;
+        } & {
+            product: P;
+            variant: V;
+        })[] | undefined;
+    }>;
 }>;
 export {};

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

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@scayle/storefront-nuxt",
   "type": "module",
-  "version": "7.75.0",
+  "version": "7.76.0",
   "description": "Nuxt integration for the SCAYLE Commerce Engine and Storefront API",
   "author": "SCAYLE Commerce Engine",
   "license": "MIT",
@@ -58,7 +58,7 @@
   },
   "dependencies": {
     "@nuxt/kit": "3.11.1",
-    "@opentelemetry/api": "1.8.0",
+    "@opentelemetry/api": "1.9.0",
     "@scayle/h3-session": "0.4.0",
     "@scayle/storefront-core": "7.55.0",
     "@scayle/unstorage-compression-driver": "0.1.3",
@@ -74,7 +74,7 @@
     "ufo": "1.5.3",
     "uncrypto": "0.1.3",
     "unstorage": "1.10.2",
-    "vue-router": "4.3.2",
+    "vue-router": "4.3.3",
     "yn": "5.0.0",
     "zod": "3.23.8"
   },
@@ -86,7 +86,7 @@
     "@scayle/eslint-config-storefront": "4.2.0",
     "@scayle/eslint-plugin-vue-composable": "0.2.0",
     "@types/node": "20.14.2",
-    "dprint": "0.46.1",
+    "dprint": "0.46.2",
     "eslint": "9.4.0",
     "eslint-formatter-gitlab": "5.1.0",
     "fishery": "2.2.2",
@@ -96,7 +96,7 @@
     "nuxt": "3.11.1",
     "publint": "0.2.8",
     "vitest": "1.6.0",
-    "vue-tsc": "2.0.19"
+    "vue-tsc": "2.0.21"
   },
   "peerDependencies": {
     "h3": "^1.10.0",