@scayle/storefront-nuxt 7.95.4 → 8.0.0

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

@@ -1,210 +0,0 @@
-import { useState } from "nuxt/app";
-import { computed } from "vue";
-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: "/" }
-} = {}, _key) {
-  const key = optionsKey ?? _key ?? "useFacet";
-  const currentPath = useState(
-    `${key}-path`,
-    () => params.initialPath ?? "/"
-  );
-  const currentPage = useState(
-    `${key}-currentPage`,
-    () => 1
-  );
-  const currentPerPage = useState(`${key}-itemsPerPage`, () => 20);
-  const currentWhereCondition = useState(
-    `${key}-whereCondition`
-  );
-  const currentSorting = useState(`${key}-sorting`);
-  const currentPricePromotionKey = useState(`${key}-pricePromotionKey`);
-  const currentCacheParams = useState(
-    `${key}-currentCacheParams`
-  );
-  const currentOrFiltersOperator = useState(
-    `${key}-orFilterOperator`
-  );
-  const productCountWhere = useState(
-    `${key}-productCountWhereCondition`
-  );
-  const categoriesPromise = useCategories({
-    params: () => ({
-      path: currentPath.value,
-      includeHidden: params.with?.product?.categories?.includeHidden || void 0
-    }),
-    options: { immediate: false },
-    key: `${key}-categories`
-  });
-  const productsPromise = useProducts({
-    params: () => ({
-      page: currentPage.value,
-      perPage: currentPerPage.value,
-      with: params.with?.product,
-      category: currentPath.value,
-      includeSoldOut: params.includeSoldOut,
-      includeSellableForFree: params.includeSellableForFree,
-      where: currentWhereCondition.value,
-      sort: currentSorting.value,
-      pricePromotionKey: currentPricePromotionKey.value,
-      cache: currentCacheParams.value,
-      orFiltersOperator: currentOrFiltersOperator.value
-    }),
-    options: { immediate: false },
-    key: `${key}-products`
-  });
-  const productsCountPromise = useProductsCount({
-    params: () => ({
-      category: currentPath.value,
-      includedFilters: params.includedFilters,
-      includeSoldOut: params.includeSoldOut,
-      includeSellableForFree: params.includeSellableForFree,
-      where: productCountWhere.value,
-      orFiltersOperator: currentOrFiltersOperator.value
-    }),
-    options: { immediate: false },
-    key: `${key}-productCount`
-  });
-  const filtersPromise = useFilters({
-    params: () => ({
-      category: currentPath.value,
-      includedFilters: params.includedFilters,
-      includeSoldOut: params.includeSoldOut,
-      includeSellableForFree: params.includeSellableForFree,
-      where: currentWhereCondition.value,
-      orFiltersOperator: currentOrFiltersOperator.value
-    }),
-    options: { immediate: false },
-    key: `${key}-filters`
-  });
-  const {
-    data: categoryData,
-    fetch: refreshCategories,
-    fetching: categoriesFetching,
-    error: categoriesError,
-    status: categoriesStatus
-  } = categoriesPromise;
-  const {
-    data: productData,
-    fetch: _refreshProducts,
-    fetching: productsFetching,
-    error: productError,
-    status: productStatus
-  } = productsPromise;
-  const {
-    data: productCountData,
-    fetch: _refreshProductCount,
-    fetching: productCountFetching,
-    error: productCountError,
-    status: productCountStatus
-  } = productsCountPromise;
-  const {
-    data: filterData,
-    fetch: refreshFilters,
-    fetching: filtersFetching,
-    error: filterError,
-    status: filterStatus
-  } = filtersPromise;
-  const categories = computed(() => categoryData.value?.categories);
-  const selectedCategory = computed(() => categoryData.value?.activeNode);
-  const pagination = computed(() => productData.value?.pagination);
-  const products = computed(() => productData.value?.products);
-  const filters = computed(() => filterData.value?.filters);
-  const unfilteredCount = computed(() => filterData.value?.unfilteredCount);
-  const refreshProductCount = async ({
-    where = void 0
-  } = {}) => {
-    productCountWhere.value = where;
-    if (productCountFetching.value) {
-      return;
-    }
-    await _refreshProductCount();
-  };
-  const fetchProducts = async ({
-    path,
-    page = 1,
-    perPage = 20,
-    where = void 0,
-    sort = void 0,
-    pricePromotionKey = "",
-    cache,
-    orFiltersOperator = void 0
-  }) => {
-    currentPath.value = path;
-    currentPage.value = page;
-    currentPerPage.value = perPage;
-    currentWhereCondition.value = where;
-    currentSorting.value = sort;
-    currentPricePromotionKey.value = pricePromotionKey;
-    currentCacheParams.value = cache;
-    currentOrFiltersOperator.value = orFiltersOperator;
-    if (categoriesFetching.value || productsFetching.value || filtersFetching.value) {
-      return;
-    }
-    await Promise.all([
-      refreshCategories(),
-      _refreshProducts(),
-      refreshFilters()
-    ]);
-    return true;
-  };
-  const filterProducts = async ({
-    where = void 0,
-    page,
-    sort = void 0,
-    orFiltersOperator = void 0
-  }) => {
-    currentWhereCondition.value = where;
-    currentPage.value = page;
-    currentSorting.value = sort;
-    currentOrFiltersOperator.value = orFiltersOperator;
-    await _refreshProducts();
-  };
-  const fetchPage = async (pageToFetch) => {
-    currentPage.value = pageToFetch;
-    await _refreshProducts();
-  };
-  return extendPromise(
-    Promise.all([
-      categoriesPromise,
-      productsPromise,
-      productsCountPromise,
-      filtersPromise
-    ]).then(() => ({})),
-    {
-      // filter data
-      filters,
-      filtersFetching,
-      unfilteredCount,
-      filterStatus,
-      filterError,
-      // filter preview
-      productCountData,
-      refreshProductCount,
-      productCountFetching,
-      productCountError,
-      productCountStatus,
-      // product data
-      products,
-      pagination,
-      productsFetching,
-      filterProducts,
-      productError,
-      productStatus,
-      // category data
-      categories,
-      selectedCategory,
-      categoriesFetching,
-      categoriesError,
-      categoriesStatus,
-      // other
-      fetchProducts,
-      fetchPage
-    }
-  );
-}

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

@@ -1,13 +0,0 @@
-import { type FilterParams, type TransformedFilter, type Filter, type SortingValueKey } from '@scayle/storefront-core';
-type Options = {
-    defaultSort?: SortingValueKey;
-};
-/** @deprecated The Storefront Boilerplate contains a `useQueryFilterState` composable you can use instead. **/
-export declare function useQueryFilterState(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 {};

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

@@ -1,78 +0,0 @@
-import {
-  isFilterActive,
-  transformToWhereCondition,
-  serializeFilters,
-  deserializeFilters,
-  getSortByValue
-} from "@scayle/storefront-core";
-import { computed } from "vue";
-import { getCurrentPage } from "../../utils/route.js";
-import { useRoute, useRouter } from "#imports";
-const DEFAULT_QUERY_KEYS = ["page", "sort", "term"];
-function queryValueToString(value) {
-  return Array.isArray(value) ? value.map((v) => v?.toString()).filter(Boolean).join(",") : value?.toString();
-}
-const isEqual = (x, y) => {
-  if (Object.is(x, y)) {
-    return true;
-  }
-  if (typeof x !== "object" || x === null || typeof y !== "object" || y === null) {
-    return x === y;
-  }
-  const keys = Object.keys(x);
-  return keys.length === Object.keys(y).length && keys.every((key) => Reflect.has(y, key) && isEqual(x[key], y[key]));
-};
-export function useQueryFilterState(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)
-      ).map(([key, value]) => [key, queryValueToString(value)]).filter(([_key, value]) => !!value)
-    );
-    return deserializeFilters(allowedFilters);
-  });
-  const isActiveFilter = (filter) => {
-    if (!filter) {
-      return Object.values(activeFilters.value).length === 0;
-    }
-    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

@@ -1,14 +0,0 @@
-import type { SearchInput, SearchOptions, TypeaheadSuggestionsEndpointResponseData } from '@scayle/storefront-core';
-type Options = Partial<{
-    params: SearchOptions;
-    key: string;
-}>;
-/** @deprecated `useSearch` is deprecated. Please, use `useSearchSuggestions` or `useSearchResolve` */
-export declare function useSearch({ params, key }?: Options): {
-    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>;
-};
-export {};

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

@@ -1,44 +0,0 @@
-import { useState } from "nuxt/app";
-import { useRpcCall } from "../core/useRpcCall.js";
-export function 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 searchProductsRpc = useRpcCall("searchProducts");
-  const search = async ({ term, slug, productLimit }) => {
-    pending.value = true;
-    status.value = "pending";
-    if (!term) {
-      return;
-    }
-    try {
-      data.value = await searchProductsRpc({
-        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
-  };
-}