@scayle/storefront-nuxt 7.36.3

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

@@ -0,0 +1,20 @@
+import { useRpc } from "../core/useRpc.mjs";
+export async function useNavigationTree({
+  params,
+  options,
+  key = "useNavigationTree"
+} = {}) {
+  const { data, fetching, fetch, error, status } = await useRpc(
+    "fetchNavigationTreeById",
+    key,
+    params,
+    options
+  );
+  return {
+    data,
+    fetching,
+    fetch,
+    error,
+    status
+  };
+}

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

@@ -0,0 +1,16 @@
+import { RpcMethodParameters } from '@scayle/storefront-core';
+import { RpcOptions } from '../core/useRpc';
+import type { MaybeRefOrGetter } from '#imports';
+type Options = Partial<{
+    params: MaybeRefOrGetter<RpcMethodParameters<'fetchAllNavigationTrees'>>;
+    options: RpcOptions;
+    key: string;
+}>;
+export declare function useNavigationTrees({ params, options, key, }?: Options): Promise<{
+    data: import("vue").Ref<import("@aboutyou/backbone").NavigationAllEndpointResponseData>;
+    fetching: import("vue").Ref<boolean>;
+    fetch: () => Promise<void>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError | undefined>;
+    status: import("vue").Ref<import("../core/useRpc").Status>;
+}>;
+export {};

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

@@ -0,0 +1,20 @@
+import { useRpc } from "../core/useRpc.mjs";
+export async function useNavigationTrees({
+  params = {},
+  options,
+  key = "useNavigationTrees"
+} = {}) {
+  const { data, fetching, fetch, error, status } = await useRpc(
+    "fetchAllNavigationTrees",
+    key,
+    params,
+    options
+  );
+  return {
+    data,
+    fetching,
+    fetch,
+    error,
+    status
+  };
+}

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

@@ -0,0 +1,89 @@
+import { RpcMethodParameters, Order } from '@scayle/storefront-core';
+import { RpcOptions } from '../core/useRpc';
+import type { MaybeRefOrGetter } from '#imports';
+type Options = Partial<{
+    params: MaybeRefOrGetter<RpcMethodParameters<'getOrderById'>>;
+    options: RpcOptions;
+    key: string;
+}>;
+export declare function useOrder<P = {
+    [k: string]: unknown;
+}, V = {
+    [k: string]: unknown;
+}>({ params, options, key }?: Options): Promise<{
+    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: "sale" | "campaign" | "voucher";
+                    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" | "cancelled" | "delivered" | "returned" | "unavailable";
+            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;
+    }>;
+    fetching: import("vue").Ref<boolean>;
+    fetch: () => Promise<void>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError | undefined>;
+    status: import("vue").Ref<import("../core/useRpc").Status>;
+}>;
+export {};

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

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

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

@@ -0,0 +1,89 @@
+import { RpcMethodParameters, Order } from '@scayle/storefront-core';
+import { RpcOptions } from '../core/useRpc';
+import type { MaybeRefOrGetter } from '#imports';
+type Options = Partial<{
+    params: MaybeRefOrGetter<RpcMethodParameters<'getOrderDataByCbd'>>;
+    options: RpcOptions;
+    key: string;
+}>;
+export declare function useOrderConfirmation<P = {
+    [k: string]: unknown;
+}, V = {
+    [k: string]: unknown;
+}>({ params, options, key }?: Options): Promise<{
+    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: "sale" | "campaign" | "voucher";
+                    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" | "cancelled" | "delivered" | "returned" | "unavailable";
+            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;
+    }>;
+    fetching: import("vue").Ref<boolean>;
+    fetch: () => Promise<void>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError | undefined>;
+    status: import("vue").Ref<import("../core/useRpc").Status>;
+}>;
+export {};

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

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

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

@@ -0,0 +1,16 @@
+import { type RpcMethodParameters } from '@scayle/storefront-core';
+import { type RpcOptions } from '../core/useRpc';
+import { type MaybeRefOrGetter } from '#imports';
+type Options = Partial<{
+    params: MaybeRefOrGetter<RpcMethodParameters<'getProductById'>>;
+    options: RpcOptions;
+    key: string;
+}>;
+export declare function useProduct({ params, options, key, }?: Options): Promise<{
+    data: import("vue").Ref<import("@scayle/storefront-core").Product>;
+    fetching: import("vue").Ref<boolean>;
+    fetch: () => Promise<void>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError | undefined>;
+    status: import("vue").Ref<import("../core/useRpc").Status>;
+}>;
+export {};

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

@@ -0,0 +1,20 @@
+import { useRpc } from "../core/useRpc.mjs";
+export async function useProduct({
+  params,
+  options,
+  key = "useProduct"
+} = {}) {
+  const { data, fetching, fetch, error, status } = await useRpc(
+    "getProductById",
+    key,
+    params,
+    options
+  );
+  return {
+    data,
+    fetching,
+    fetch,
+    error,
+    status
+  };
+}

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

@@ -0,0 +1,20 @@
+import { type RpcMethodParameters } from '@scayle/storefront-core';
+import { type RpcOptions } from '../core/useRpc';
+import { type MaybeRefOrGetter } from '#imports';
+type Options = Partial<{
+    params: MaybeRefOrGetter<RpcMethodParameters<'getProductsByCategory'>>;
+    options: RpcOptions;
+    key: string;
+}>;
+export declare function useProducts({ params, options, key, }?: Options): Promise<{
+    data: import("vue").Ref<import("@scayle/storefront-core").ProductsResponse | ({
+        pagination: import("@scayle/storefront-core").Pagination;
+    } & {
+        products: import("@scayle/storefront-core").Product[];
+    })>;
+    fetching: import("vue").Ref<boolean>;
+    fetch: () => Promise<void>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError | undefined>;
+    status: import("vue").Ref<import("../core/useRpc").Status>;
+}>;
+export {};

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

@@ -0,0 +1,20 @@
+import { useRpc } from "../core/useRpc.mjs";
+export async function useProducts({
+  params,
+  options,
+  key = "useProducts"
+} = {}) {
+  const { data, fetching, fetch, error, status } = await useRpc(
+    "getProductsByCategory",
+    key,
+    params,
+    options
+  );
+  return {
+    data,
+    fetching,
+    fetch,
+    error,
+    status
+  };
+}

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

@@ -0,0 +1,16 @@
+import { type RpcMethodParameters } from '@scayle/storefront-core';
+import { type RpcOptions } from '../core/useRpc';
+import { type MaybeRefOrGetter } from '#imports';
+type Options = Partial<{
+    params: MaybeRefOrGetter<RpcMethodParameters<'getProductsByIds'>>;
+    options: RpcOptions;
+    key: string;
+}>;
+export declare function useProductsByIds({ params, options, key, }?: Options): Promise<{
+    data: import("vue").Ref<import("@scayle/storefront-core").Product[]>;
+    fetching: import("vue").Ref<boolean>;
+    fetch: () => Promise<void>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError | undefined>;
+    status: import("vue").Ref<import("../core/useRpc").Status>;
+}>;
+export {};

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

@@ -0,0 +1,20 @@
+import { useRpc } from "../core/useRpc.mjs";
+export async function useProductsByIds({
+  params,
+  options,
+  key = "useProductsByIds"
+} = {}) {
+  const { data, fetching, fetch, error, status } = await useRpc(
+    "getProductsByIds",
+    key,
+    params,
+    options
+  );
+  return {
+    data,
+    fetching,
+    fetch,
+    error,
+    status
+  };
+}

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

@@ -0,0 +1,16 @@
+import { RpcMethodParameters } from '@scayle/storefront-core';
+import { RpcOptions } from '../core/useRpc';
+import type { MaybeRefOrGetter } from '#imports';
+type Options = Partial<{
+    params: MaybeRefOrGetter<RpcMethodParameters<'getProductsCount'>>;
+    options: RpcOptions;
+    key: string;
+}>;
+export declare function useProductsCount({ params, options, key, }?: Options): Promise<{
+    data: import("vue").Ref<import("@scayle/storefront-core").FetchProductsCountResponse>;
+    fetching: import("vue").Ref<boolean>;
+    fetch: () => Promise<void>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError | undefined>;
+    status: import("vue").Ref<import("../core/useRpc").Status>;
+}>;
+export {};

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

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

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

@@ -0,0 +1,16 @@
+import { type RpcMethodParameters } from '@scayle/storefront-core';
+import { type RpcOptions } from '../core/useRpc';
+import { type MaybeRefOrGetter } from '#imports';
+type Options = Partial<{
+    params: MaybeRefOrGetter<RpcMethodParameters<'getPromotions'>>;
+    options: RpcOptions;
+    key: string;
+}>;
+export declare function usePromotions({ params, options, key, }?: Options): Promise<{
+    data: import("vue").Ref<import("@scayle/storefront-core").PromotionsResponseData>;
+    fetching: import("vue").Ref<boolean>;
+    fetch: () => Promise<void>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError | undefined>;
+    status: import("vue").Ref<import("../core/useRpc").Status>;
+}>;
+export {};

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

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

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

@@ -0,0 +1,16 @@
+import { type RpcMethodParameters } from '@scayle/storefront-core';
+import { type RpcOptions } from '../core/useRpc';
+import { type MaybeRefOrGetter } from '#imports';
+type Options = Partial<{
+    params: MaybeRefOrGetter<RpcMethodParameters<'getPromotionsByIds'>>;
+    options: RpcOptions;
+    key: string;
+}>;
+export declare function usePromotionsByIds({ params, options, key, }?: Options): Promise<{
+    data: import("vue").Ref<import("@scayle/storefront-core").PromotionsResponseData>;
+    fetching: import("vue").Ref<boolean>;
+    fetch: () => Promise<void>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError | undefined>;
+    status: import("vue").Ref<import("../core/useRpc").Status>;
+}>;
+export {};

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

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

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

@@ -0,0 +1,12 @@
+import { FilterParams, SortingValueKey, TransformedFilter, Filter } from '@scayle/storefront-core';
+type Options = {
+    defaultSort?: SortingValueKey;
+};
+declare const _default: (options?: Options) => {
+    activeFilters: import("vue").ComputedRef<Filter>;
+    applyFilters: (filter?: Filter, scrollToTop?: boolean) => Promise<void>;
+    isActiveFilter: (filter?: TransformedFilter) => any;
+    resetFilterUrl: () => Promise<void>;
+    productConditions: import("vue").ComputedRef<FilterParams>;
+};
+export default _default;

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

@@ -0,0 +1,66 @@
+import { isEmpty, isEqual } from "radash";
+import {
+  getSortByValue,
+  isFilterActive,
+  transformToWhereCondition,
+  serializeFilters,
+  deserializeFilters
+} from "@scayle/storefront-core";
+import { computed } from "vue";
+import { getCurrentPage } from "../../utils/route.mjs";
+import { useRoute, useRouter } from "#imports";
+const DEFAULT_QUERY_KEYS = ["page", "sort", "term"];
+export default (options = {}) => {
+  const router = useRouter();
+  const route = useRoute();
+  const activeFilters = computed(() => {
+    const allowedFilters = Object.fromEntries(
+      Object.entries(route.query).filter(
+        ([key]) => !DEFAULT_QUERY_KEYS.includes(key)
+      )
+    );
+    return deserializeFilters(allowedFilters);
+  });
+  const isActiveFilter = (filter) => {
+    if (!filter) {
+      return isEmpty(activeFilters.value);
+    }
+    return isFilterActive(activeFilters.value, filter);
+  };
+  const applyFilters = async (filter, scrollToTop = true) => {
+    const newQuery = {
+      sort: route.query.sort,
+      term: route.query.term,
+      ...filter ? serializeFilters(filter) : {}
+    };
+    if (isEqual(route.query, newQuery)) {
+      return;
+    }
+    await router.push({
+      query: { ...newQuery }
+    });
+    if (scrollToTop) {
+      window.scroll({
+        behavior: "smooth",
+        top: 0
+      });
+    }
+  };
+  const resetFilterUrl = async () => {
+    await router.replace({ query: { term: route.query.term } });
+  };
+  const generateFilterParams = () => {
+    return {
+      where: { ...transformToWhereCondition(activeFilters.value) },
+      page: getCurrentPage(route.query),
+      sort: getSortByValue(route.query?.sort || "", options?.defaultSort)
+    };
+  };
+  return {
+    activeFilters,
+    applyFilters,
+    isActiveFilter,
+    resetFilterUrl,
+    productConditions: computed(() => generateFilterParams())
+  };
+};

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

@@ -0,0 +1,13 @@
+import { type SearchInput, type SearchOptions } from '@scayle/storefront-core';
+type Options = Partial<{
+    params: SearchOptions;
+    key: string;
+}>;
+export declare const useSearch: ({ params, key }?: Options) => {
+    data: any;
+    pending: any;
+    searchQuery: any;
+    resetSearch: () => void;
+    search: ({ term, slug, productLimit }: SearchInput) => Promise<void>;
+};
+export {};

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

@@ -0,0 +1,49 @@
+import { rpcCall } from "../../rpc/rpcCall.mjs";
+import { useCurrentShop } from "../core/useCurrentShop.mjs";
+import { useState, useNuxtApp, toValue } from "#imports";
+export const useSearch = ({ params, key = "search" } = {}) => {
+  const data = useState(
+    `${key}-data`,
+    () => void 0
+  );
+  const searchQuery = useState(`${key}-searchQuery`, () => "");
+  const pending = useState(`${key}-pending`, () => false);
+  const error = useState(`${key}-error`, () => void 0);
+  const status = useState(`${key}-error`, () => "idle");
+  const shop = useCurrentShop();
+  const search = async ({ term, slug, productLimit }) => {
+    pending.value = true;
+    status.value = "pending";
+    if (!term) {
+      return;
+    }
+    try {
+      data.value = await rpcCall(
+        useNuxtApp(),
+        "searchProducts",
+        toValue(shop)
+      )({
+        term: String(term),
+        slug,
+        with: params?.with,
+        productLimit
+      });
+    } catch (e) {
+      error.value = e;
+    } finally {
+      pending.value = false;
+      status.value = error.value ? "error" : "success";
+    }
+  };
+  const resetSearch = () => {
+    searchQuery.value = "";
+    data.value = { suggestions: [] };
+  };
+  return {
+    data,
+    pending,
+    searchQuery,
+    resetSearch,
+    search
+  };
+};

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

@@ -0,0 +1,13 @@
+import { RpcOptions } from '../core/useRpc';
+type Options = Partial<{
+    options: RpcOptions;
+    key: string;
+}>;
+export declare function useShopConfiguration({ options, key, }?: Options): Promise<{
+    data: import("vue").Ref<import("@aboutyou/backbone/endpoints/shopconfiguration/shopconfiguration").ShopConfigurationResponseData>;
+    fetching: import("vue").Ref<boolean>;
+    fetch: () => Promise<void>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError | undefined>;
+    status: import("vue").Ref<import("../core/useRpc").Status>;
+}>;
+export {};