@scayle/storefront-nuxt 7.85.8 → 7.85.10

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters, RpcMethodReturnType } from '@scayle/storefront-core';
-import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc';
+import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from '#imports';
 type UseCategoriesBaseReturn<DataT, PickKeys extends KeysOf<DataT>, DefaultT> = Pick<Awaited<UseRpcReturn<'getCategoriesByPath', DataT, PickKeys, DefaultT>>, 'data' | 'error' | 'status' | 'fetch' | 'fetching' | 'refresh'> & {
     getCategoryById: (id: number, includeHidden?: true) => RpcMethodReturnType<'getCategoryById'>;

package/dist/runtime/composables/storefront/{useCategories.mjs → useCategories.js}

@@ -1,6 +1,6 @@
-import { useRpc } from "../core/useRpc.mjs";
-import { extendPromise } from "../../utils/promise.mjs";
-import { useRpcCall } from "../core/useRpcCall.mjs";
+import { useRpc } from "../core/useRpc.js";
+import { extendPromise } from "../../utils/promise.js";
+import { useRpcCall } from "../core/useRpcCall.js";
 export function useCategories({
   params,
   options,

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc';
+import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from '#imports';
 export declare function useCategoryById<DataT = NormalizedRpcResponse<'getCategoryById'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getCategoryById'>>;

package/dist/runtime/composables/storefront/{useCategoryById.mjs → useCategoryById.js}

@@ -1,4 +1,4 @@
-import { useRpc } from "../core/useRpc.mjs";
+import { useRpc } from "../core/useRpc.js";
 export function useCategoryById({
   params,
   options,

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc';
+import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from '#imports';
 export declare function useCategoryByPath<DataT = NormalizedRpcResponse<'getCategoryByPath'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }: {
     params: MaybeRefOrGetter<RpcMethodParameters<'getCategoryByPath'>>;

package/dist/runtime/composables/storefront/{useCategoryByPath.mjs → useCategoryByPath.js}

@@ -1,4 +1,4 @@
-import { useRpc } from "../core/useRpc.mjs";
+import { useRpc } from "../core/useRpc.js";
 export function useCategoryByPath({
   params,
   options,

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc';
+import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from '#imports';
 export declare function useCurrentPromotions<DataT = NormalizedRpcResponse<'getCurrentPromotions'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getCurrentPromotions'>>;

package/dist/runtime/composables/storefront/{useCurrentPromotions.mjs → useCurrentPromotions.js}

@@ -1,4 +1,4 @@
-import { useRpc } from "../core/useRpc.mjs";
+import { useRpc } from "../core/useRpc.js";
 export function useCurrentPromotions({
   params,
   options,

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/{useFacet.mjs → useFacet.js}

@@ -1,10 +1,10 @@
 import { useState } from "nuxt/app";
 import { computed } from "vue";
-import { useCategories } from "../storefront/useCategories.mjs";
-import { useFilters } from "../storefront/useFilters.mjs";
-import { useProducts } from "../storefront/useProducts.mjs";
-import { useProductsCount } from "../storefront/useProductsCount.mjs";
-import { extendPromise } from "../../utils/promise.mjs";
+import { useCategories } from "../storefront/useCategories.js";
+import { useFilters } from "../storefront/useFilters.js";
+import { useProducts } from "../storefront/useProducts.js";
+import { useProductsCount } from "../storefront/useProductsCount.js";
+import { extendPromise } from "../../utils/promise.js";
 export function useFacet({
   key: optionsKey,
   params = { initialPath: "/" }

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc';
+import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from '#imports';
 export declare function useFilters<DataT = NormalizedRpcResponse<'getFilters'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getFilters'>>;

package/dist/runtime/composables/storefront/{useFilters.mjs → useFilters.js}

@@ -1,4 +1,4 @@
-import { useRpc } from "../core/useRpc.mjs";
+import { useRpc } from "../core/useRpc.js";
 export function useFilters({
   params,
   options,

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc';
+import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from '#imports';
 export declare function useNavigationTree<DataT = NormalizedRpcResponse<'fetchNavigationTreeById'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'fetchNavigationTreeById'>>;

package/dist/runtime/composables/storefront/{useNavigationTree.mjs → useNavigationTree.js}

@@ -1,4 +1,4 @@
-import { useRpc } from "../core/useRpc.mjs";
+import { useRpc } from "../core/useRpc.js";
 export function useNavigationTree({
   params,
   options,

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { UseRpcReturn, UseRpcOptions, NormalizedRpcResponse, KeysOf } from '../core/useRpc';
+import type { UseRpcReturn, UseRpcOptions, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from '#imports';
 export declare function useNavigationTrees<DataT = NormalizedRpcResponse<'fetchAllNavigationTrees'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'fetchAllNavigationTrees'>>;

package/dist/runtime/composables/storefront/{useNavigationTrees.mjs → useNavigationTrees.js}

@@ -1,4 +1,4 @@
-import { useRpc } from "../core/useRpc.mjs";
+import { useRpc } from "../core/useRpc.js";
 export function useNavigationTrees({
   params = {},
   options,

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

@@ -1,6 +1,6 @@
 import type { RpcMethodParameters, Order } from '@scayle/storefront-core';
 import type { AsyncDataOptions } from 'nuxt/app';
-import { type RpcOptions, type KeysOf, type ExtendedAsyncData } from '../core/useRpc';
+import { type RpcOptions, type KeysOf, type ExtendedAsyncData } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
 type ItemsType = Exclude<Order['items'], undefined>;
 type NewItemsType<P, V> = Exclude<ItemsType[number], 'product' | 'variant'> & {

package/dist/runtime/composables/storefront/{useOrder.mjs → useOrder.js}

@@ -1,6 +1,6 @@
 import {
   useRpc
-} from "../core/useRpc.mjs";
+} from "../core/useRpc.js";
 export function useOrder({ params, options, key: _key } = {}, key) {
   return useRpc(
     "getOrderById",

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

@@ -1,6 +1,6 @@
 import type { RpcMethodParameters, Order } from '@scayle/storefront-core';
 import type { AsyncDataOptions } from 'nuxt/app';
-import type { RpcOptions, ExtendedAsyncData, KeysOf } from '../core/useRpc';
+import type { RpcOptions, ExtendedAsyncData, KeysOf } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from 'vue';
 type ItemsType = Exclude<Order['items'], undefined>;
 type NewItemsType<P, V> = Exclude<ItemsType[number], 'product' | 'variant'> & {

package/dist/runtime/composables/storefront/{useOrderConfirmation.mjs → useOrderConfirmation.js}

@@ -1,4 +1,4 @@
-import { useRpc } from "../core/useRpc.mjs";
+import { useRpc } from "../core/useRpc.js";
 export function useOrderConfirmation({ params, options, key: _key } = {}, key) {
   return useRpc(
     "getOrderDataByCbd",

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc';
+import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from '#imports';
 export declare function useProduct<DataT = NormalizedRpcResponse<'getProductById'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getProductById'>>;

package/dist/runtime/composables/storefront/{useProduct.mjs → useProduct.js}

@@ -1,4 +1,4 @@
-import { useRpc } from "../core/useRpc.mjs";
+import { useRpc } from "../core/useRpc.js";
 export function useProduct({
   params,
   options,

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc';
+import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from '#imports';
 export declare function useProducts<DataT = NormalizedRpcResponse<'getProductsByCategory'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getProductsByCategory'>>;

package/dist/runtime/composables/storefront/{useProducts.mjs → useProducts.js}

@@ -1,4 +1,4 @@
-import { useRpc } from "../core/useRpc.mjs";
+import { useRpc } from "../core/useRpc.js";
 export function useProducts({
   params,
   options,

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc';
+import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from '#imports';
 export declare function useProductsByIds<DataT = NormalizedRpcResponse<'getProductsByIds'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getProductsByIds'>>;

package/dist/runtime/composables/storefront/{useProductsByIds.mjs → useProductsByIds.js}

@@ -1,4 +1,4 @@
-import { useRpc } from "../core/useRpc.mjs";
+import { useRpc } from "../core/useRpc.js";
 export function useProductsByIds({
   params,
   options,

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc';
+import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from '#imports';
 export declare function useProductsByReferenceKeys<DataT = NormalizedRpcResponse<'getProductsByReferenceKeys'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getProductsByReferenceKeys'>>;

package/dist/runtime/composables/storefront/{useProductsByReferenceKeys.mjs → useProductsByReferenceKeys.js}

@@ -1,4 +1,4 @@
-import { useRpc } from "../core/useRpc.mjs";
+import { useRpc } from "../core/useRpc.js";
 export function useProductsByReferenceKeys({
   params,
   options,

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc';
+import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from '#imports';
 export declare function useProductsCount<DataT = NormalizedRpcResponse<'getProductsCount'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getProductsCount'>>;

package/dist/runtime/composables/storefront/{useProductsCount.mjs → useProductsCount.js}

@@ -1,4 +1,4 @@
-import { useRpc } from "../core/useRpc.mjs";
+import { useRpc } from "../core/useRpc.js";
 export function useProductsCount({
   params,
   options,

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc';
+import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from '#imports';
 export declare function usePromotions<DataT = NormalizedRpcResponse<'getPromotions'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getPromotions'>>;

package/dist/runtime/composables/storefront/{usePromotions.mjs → usePromotions.js}

@@ -1,4 +1,4 @@
-import { useRpc } from "../core/useRpc.mjs";
+import { useRpc } from "../core/useRpc.js";
 export function usePromotions({
   params,
   options,

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc';
+import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from '#imports';
 export declare function usePromotionsByIds<DataT = NormalizedRpcResponse<'getPromotionsByIds'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getPromotionsByIds'>>;

package/dist/runtime/composables/storefront/{usePromotionsByIds.mjs → usePromotionsByIds.js}

@@ -1,4 +1,4 @@
-import { useRpc } from "../core/useRpc.mjs";
+import { useRpc } from "../core/useRpc.js";
 export function usePromotionsByIds({
   params,
   options,

package/dist/runtime/composables/storefront/{useQueryFilterState.mjs → useQueryFilterState.js}

@@ -6,7 +6,7 @@ import {
   getSortByValue
 } from "@scayle/storefront-core";
 import { computed } from "vue";
-import { getCurrentPage } from "../../utils/route.mjs";
+import { getCurrentPage } from "../../utils/route.js";
 import { useRoute, useRouter } from "#imports";
 const DEFAULT_QUERY_KEYS = ["page", "sort", "term"];
 function queryValueToString(value) {

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/{useSearch.mjs → useSearch.js}

@@ -1,5 +1,5 @@
 import { useState } from "nuxt/app";
-import { useRpcCall } from "../core/useRpcCall.mjs";
+import { useRpcCall } from "../core/useRpcCall.js";
 export function useSearch({ params, key = "search" } = {}) {
   const data = useState(
     `${key}-data`,

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

@@ -1,4 +1,4 @@
-import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc';
+import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
 export declare function useShopConfiguration<DataT = NormalizedRpcResponse<'getShopConfiguration'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ options, key: _key, }?: Partial<{
     options: UseRpcOptions<'getShopConfiguration', DataT, PickKeys, DefaultT>;
     /** @deprecated use the second argument of the composable to define the key */

package/dist/runtime/composables/storefront/{useShopConfiguration.mjs → useShopConfiguration.js}

@@ -1,4 +1,4 @@
-import { useRpc } from "../core/useRpc.mjs";
+import { useRpc } from "../core/useRpc.js";
 export function useShopConfiguration({
   options,
   key: _key

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>;

package/dist/runtime/composables/storefront/{useStorefrontSearch.mjs → useStorefrontSearch.js}

@@ -1,5 +1,5 @@
 import { useState } from "nuxt/app";
-import { useRpcCall } from "../core/useRpcCall.mjs";
+import { useRpcCall } from "../core/useRpcCall.js";
 export function useStorefrontSearch(searchQuery, { params, key = "search" } = {}) {
   const data = useState(
     `${key}-data`,

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

@@ -1,4 +1,4 @@
-import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc';
+import type { UseRpcOptions, UseRpcReturn, NormalizedRpcResponse, KeysOf } from '../core/useRpc.js';
 export declare function useUserAddresses<DataT = NormalizedRpcResponse<'getShopUserAddresses'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ options, key: _key, }?: Partial<{
     options: UseRpcOptions<'getShopUserAddresses', DataT, PickKeys, DefaultT>;
     /** @deprecated use the second argument of the composable to define the key */

package/dist/runtime/composables/storefront/{useUserAddresses.mjs → useUserAddresses.js}

@@ -1,4 +1,4 @@
-import { useRpc } from "../core/useRpc.mjs";
+import { useRpc } from "../core/useRpc.js";
 export function useUserAddresses({
   options,
   key: _key

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

@@ -1,5 +1,5 @@
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc';
+import type { KeysOf, UseRpcOptions, UseRpcReturn, NormalizedRpcResponse } from '../core/useRpc.js';
 import type { MaybeRefOrGetter } from '#imports';
 export declare function useVariant<DataT = NormalizedRpcResponse<'getVariantById'>, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = null>({ params, options, key: _key, }?: Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getVariantById'>>;

package/dist/runtime/composables/storefront/{useVariant.mjs → useVariant.js}

@@ -1,4 +1,4 @@
-import { useRpc } from "../core/useRpc.mjs";
+import { useRpc } from "../core/useRpc.js";
 export function useVariant({
   params,
   options,

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

@@ -1,5 +1,5 @@
 import type { Product, WishlistItem, RpcMethodParameters } from '@scayle/storefront-core';
-import { type UseRpcReturn } from '../core/useRpc';
+import { type UseRpcReturn } from '../core/useRpc.js';
 import type { MaybeRefOrGetter, ComputedRef } from '#imports';
 type Options = Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getWishlist'>>;

package/dist/runtime/composables/storefront/{useWishlist.mjs → useWishlist.js}

@@ -5,10 +5,10 @@ import {
 } from "@scayle/storefront-core";
 import { useNuxtApp } from "nuxt/app";
 import { computed } from "vue";
-import { useRpc } from "../core/useRpc.mjs";
-import { extendPromise } from "../../utils/promise.mjs";
+import { useRpc } from "../core/useRpc.js";
+import { extendPromise } from "../../utils/promise.js";
 import { toValue, toRef } from "#imports";
-import { useRpcCall } from "../core/useRpcCall.mjs";
+import { useRpcCall } from "../core/useRpcCall.js";
 export function useWishlist({
   params,
   key = "useWishlist"

package/dist/runtime/composables/{useCoreLog.mjs → useCoreLog.js}

@@ -1,4 +1,4 @@
-import { useLog } from "./core/useLog.mjs";
+import { useLog } from "./core/useLog.js";
 export function useCoreLog(subSpace) {
   return useLog(subSpace ? `sfc.${subSpace}` : "sfc");
 }

package/dist/runtime/context.d.ts

@@ -3,7 +3,7 @@ import type { RuntimeConfig } from '@nuxt/schema';
 import { type H3Event } from 'h3';
 import type { Log, RpcContext, Cache as CacheInterface } from '@scayle/storefront-core';
 import { StorefrontAPIClient } from '@scayle/storefront-core';
-import type { ShopConfig, StorefrontConfig } from '../module';
+import type { ShopConfig, StorefrontConfig } from '../module.js';
 export interface ContextBuilderOptions {
     $cache: CacheInterface;
     $shopConfig: ShopConfig;

package/dist/runtime/{context.mjs → context.js}

@@ -8,8 +8,8 @@ import {
   generateBasketKey,
   generateWishlistKey
 } from "@scayle/storefront-core/dist/utils/keys";
-import { useNitroApp } from "#imports";
-import { fetchCampaignKey } from "./campaignKey.mjs";
+import { useNitroApp } from "nitropack/runtime";
+import { fetchCampaignKey } from "./campaignKey.js";
 async function getWishlistKey(appKeys, session, $log, $shopConfig) {
   return session.data.user ? await generateWishlistKey({
     keyTemplate: appKeys.wishlistKey,

package/dist/runtime/createLog.d.ts

@@ -1,4 +1,4 @@
 import type { ConsolaInstance, ConsolaOptions } from 'consola';
-import type { LogLevel } from '../types/module';
-import { Log } from './log';
+import type { LogLevel } from '../types/module.js';
+import { Log } from './log.js';
 export default function createLog(createConsola: (options?: Partial<ConsolaOptions>) => ConsolaInstance, space: string | undefined, level: LogLevel): Log;

package/dist/runtime/{createLog.mjs → createLog.js}

@@ -1,4 +1,4 @@
-import { Log } from "./log.mjs";
+import { Log } from "./log.js";
 const levelMap = {
   error: 0,
   warn: 1,

package/dist/runtime/error/handler.d.ts

@@ -1,5 +1,5 @@
 declare const resolveError: (error: Error | unknown) => {
-    statusCode: 100 | 101 | 102 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226 | 300 | 301 | 302 | 303 | 304 | 305 | 307 | 308 | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 426 | 428 | 429 | 431 | 451 | 500 | 501 | 502 | 503 | 504 | 506 | 507 | 508 | 510 | 511 | 306 | 505;
+    statusCode: 100 | 101 | 102 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226 | 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308 | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 426 | 428 | 429 | 431 | 451 | 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511;
     statusMessage: string;
     name: string;
 };

package/dist/runtime/nitro/plugins/cacheRuntimeConfig.d.ts

@@ -1,2 +1,2 @@
-declare const _default: any;
+declare const _default: import("nitropack").NitroAppPlugin;
 export default _default;

package/dist/runtime/nitro/plugins/{cacheRuntimeConfig.mjs → cacheRuntimeConfig.js}

@@ -1,4 +1,5 @@
-import { defineNitroPlugin, useRuntimeConfig } from "#imports";
+import { defineNitroPlugin } from "nitropack/runtime/plugin";
+import { useRuntimeConfig } from "#imports";
 export default defineNitroPlugin((nitroApp) => {
   const runtimeConfig = useRuntimeConfig();
   nitroApp.hooks.hook("request", (event) => {

package/dist/runtime/nitro/plugins/configValidation.d.ts

@@ -1,7 +1,12 @@
 import type { RuntimeConfig } from '@nuxt/schema';
 import type { ZodIssue } from 'zod';
 export declare const sensitiveKeys: string[];
-export declare const getValue: (object: any, pathArray: any) => string;
-export declare const formatZodError: (issues: Array<ZodIssue>, runtimeConfig: RuntimeConfig) => never[];
-declare const _default: any;
+export declare const getValue: (object: Record<string | number, unknown>, pathArray: (string | number)[]) => string;
+export declare const formatZodError: (issues: Array<ZodIssue>, runtimeConfig: RuntimeConfig) => (ZodIssue | {
+    code: string;
+    path: string;
+    message: string;
+    value?: string;
+})[];
+declare const _default: import("nitropack").NitroAppPlugin;
 export default _default;