@scayle/storefront-core 7.22.1

package/dist/helpers/productDisruptorHelper.cjs

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isFirstIndexOfRow = exports.hasDisruptorAtRow = exports.getRowByIndex = exports.getDisruptorsForRow = void 0;
+const getRowByIndex = (index, options = {
+  columns: 2,
+  page: 1,
+  perPage: 24
+}) => {
+  const {
+    columns,
+    page,
+    perPage
+  } = options;
+  const adjustedIndex = index + (page - 1) * perPage;
+  return Math.floor(adjustedIndex / columns);
+};
+exports.getRowByIndex = getRowByIndex;
+const getDisruptorsForRow = (row, disruptors) => {
+  return disruptors.reduce((c, v, _) => {
+    if (v.insert_in_row === row.toString()) {
+      c.push(v);
+    }
+    return c;
+  }, []);
+};
+exports.getDisruptorsForRow = getDisruptorsForRow;
+const isFirstIndexOfRow = (index, columns) => {
+  return index % columns === 0;
+};
+exports.isFirstIndexOfRow = isFirstIndexOfRow;
+const hasDisruptorAtRow = (row, disruptorRows) => {
+  return disruptorRows.includes(row.toString());
+};
+exports.hasDisruptorAtRow = hasDisruptorAtRow;

package/dist/helpers/productDisruptorHelper.d.ts

@@ -0,0 +1,10 @@
+export declare const getRowByIndex: (index: number, options?: {
+    columns: number;
+    page: number;
+    perPage: number;
+}) => number;
+export declare const getDisruptorsForRow: (row: number, disruptors: {
+    insert_in_row: string;
+}[]) => {}[];
+export declare const isFirstIndexOfRow: (index: number, columns: number) => boolean;
+export declare const hasDisruptorAtRow: (row: number, disruptorRows: string[]) => boolean;

package/dist/helpers/productDisruptorHelper.mjs

@@ -0,0 +1,23 @@
+export const getRowByIndex = (index, options = {
+  columns: 2,
+  page: 1,
+  perPage: 24
+}) => {
+  const { columns, page, perPage } = options;
+  const adjustedIndex = index + (page - 1) * perPage;
+  return Math.floor(adjustedIndex / columns);
+};
+export const getDisruptorsForRow = (row, disruptors) => {
+  return disruptors.reduce((c, v, _) => {
+    if (v.insert_in_row === row.toString()) {
+      c.push(v);
+    }
+    return c;
+  }, []);
+};
+export const isFirstIndexOfRow = (index, columns) => {
+  return index % columns === 0;
+};
+export const hasDisruptorAtRow = (row, disruptorRows) => {
+  return disruptorRows.includes(row.toString());
+};

package/dist/helpers/productHelpers.cjs

@@ -0,0 +1,188 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.slugify = exports.isVariantInStock = exports.isInStock = exports.getVariantCrosssellingValues = exports.getVariantBySize = exports.getVariant = exports.getTotalAppliedReductions = exports.getSizeFromVariant = exports.getSizeFromSpecificVariant = exports.getProductSiblings = exports.getProductPath = exports.getProductColors = exports.getProductAndSiblingsColors = exports.getPrice = exports.getOriginalPrice = exports.getLowestPrice = exports.getLatestCategory = exports.getCategoriesByRoute = exports.getBadgeLabel = exports.getAttribute = exports.getAppliedReductionsByCategory = exports.getAllSizesFromVariants = void 0;
+var _backbone = require("@aboutyou/backbone");
+var _radash = require("radash");
+var _slugify = _interopRequireDefault(require("slugify"));
+var _product = require("../constants/product.cjs");
+var _attributeHelpers = require("./attributeHelpers.cjs");
+var _imageHelpers = require("./imageHelpers.cjs");
+var _arrayHelpers = require("./arrayHelpers.cjs");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const slugify = url => {
+  return (0, _slugify.default)(url ?? "", {
+    lower: true,
+    remove: /[*+~.()'"!:@/#?]/g
+  });
+};
+exports.slugify = slugify;
+const BadgeLabel = {
+  NEW: "new",
+  SOLD_OUT: "sold_out",
+  ONLINE_EXCLUSIVE: "online_exclusive",
+  SUSTAINABLE: "sustainable",
+  PREMIUM: "premium",
+  DEFAULT: ""
+};
+const getPrice = variant => variant.price;
+exports.getPrice = getPrice;
+const getBadgeLabel = (params = {}) => {
+  if (!params) {
+    return BadgeLabel.DEFAULT;
+  }
+  const {
+    isNew,
+    isSoldOut,
+    isOnlineOnly,
+    isSustainable,
+    isPremium
+  } = params;
+  if (isNew) {
+    return BadgeLabel.NEW;
+  } else if (isSoldOut) {
+    return BadgeLabel.SOLD_OUT;
+  } else if (isOnlineOnly) {
+    return BadgeLabel.ONLINE_EXCLUSIVE;
+  } else if (isSustainable) {
+    return BadgeLabel.SUSTAINABLE;
+  } else if (isPremium) {
+    return BadgeLabel.PREMIUM;
+  } else {
+    return BadgeLabel.DEFAULT;
+  }
+};
+exports.getBadgeLabel = getBadgeLabel;
+const getOriginalPrice = price => {
+  return price.appliedReductions.length > 0 ? price.appliedReductions[0].amount.absoluteWithTax + price.withTax : price.withTax;
+};
+exports.getOriginalPrice = getOriginalPrice;
+const getTotalAppliedReductions = price => {
+  const total = {
+    absoluteWithTax: 0,
+    relative: 0
+  };
+  if (price) {
+    price.appliedReductions.forEach(reduction => {
+      total.absoluteWithTax += reduction.amount.absoluteWithTax;
+      total.relative += reduction.amount.relative;
+    });
+  }
+  return total;
+};
+exports.getTotalAppliedReductions = getTotalAppliedReductions;
+const getLowestPrice = variants => {
+  return variants.reduce((m, x) => m.price.withoutTax < x.price.withoutTax ? m : x).price;
+};
+exports.getLowestPrice = getLowestPrice;
+const getAppliedReductionsByCategory = (price, category) => {
+  return price.appliedReductions.filter(reduction => {
+    return reduction.category === category;
+  });
+};
+exports.getAppliedReductionsByCategory = getAppliedReductionsByCategory;
+const getSizeFromSpecificVariant = (product, variantId) => {
+  if (!product.variants) {
+    return null;
+  }
+  const variant = product.variants?.find(item => item.id === variantId);
+  return getSizeFromVariant(variant || product.variants[0]);
+};
+exports.getSizeFromSpecificVariant = getSizeFromSpecificVariant;
+const getVariant = (variants, id) => {
+  return variants?.find(variant => variant.id === id);
+};
+exports.getVariant = getVariant;
+const getSizeFromVariant = (variant, attributeName = "shopSize") => (0, _backbone.getFirstAttributeValue)(variant.attributes, attributeName);
+exports.getSizeFromVariant = getSizeFromVariant;
+const getAllSizesFromVariants = (variantsAttributes, attributeName = "shopSize") => (0, _radash.unique)(variantsAttributes.map(variant => (0, _backbone.getFirstAttributeValue)(variant.attributes, attributeName)).filter(Boolean), it => it?.id);
+exports.getAllSizesFromVariants = getAllSizesFromVariants;
+const getProductSiblings = (product, colorAttributeName = "colorDetail") => {
+  if (!product) {
+    return [];
+  }
+  const items = [product];
+  product.siblings?.forEach(item => {
+    if (!item.isActive) {
+      return;
+    }
+    items.push(item);
+  });
+  return items.map(item => ({
+    id: item.id,
+    image: (0, _imageHelpers.getImageFromList)(item.images, _product.ProductImageType.BUST, "front"),
+    colors: (0, _attributeHelpers.getAttributeValueTuples)(item.attributes, colorAttributeName)
+  }));
+};
+exports.getProductSiblings = getProductSiblings;
+const getProductColors = (product, colorAttributeName = "colorDetail") => {
+  return (0, _attributeHelpers.getAttributeValueTuples)(product.attributes, colorAttributeName).map(color => color.label);
+};
+exports.getProductColors = getProductColors;
+const getVariantBySize = (variants, size, sizeAttributeName = "shopSize") => {
+  return variants?.find(variant => (0, _attributeHelpers.getAttributeValue)(variant.attributes, sizeAttributeName) === size.value);
+};
+exports.getVariantBySize = getVariantBySize;
+const isInStock = variant => {
+  return variant.stock.quantity > 0 || variant.stock.isSellableWithoutStock === true;
+};
+exports.isInStock = isInStock;
+const isVariantInStock = (variants, size, sizeAttributeName = "shopSize") => {
+  const variant = variants?.find(variant2 => getSizeFromVariant(variant2, sizeAttributeName)?.value === size.value);
+  if (!variant) {
+    return false;
+  }
+  return isInStock(variant);
+};
+exports.isVariantInStock = isVariantInStock;
+const getAttribute = (product, key) => {
+  const values = product.attributes?.[key]?.values;
+  return values?.value ?? values?.label;
+};
+exports.getAttribute = getAttribute;
+const getProductPath = product => {
+  const name = (0, _attributeHelpers.getAttributeValue)(product.attributes, "name");
+  return `/product/${slugify(name)}-${product.id}`;
+};
+exports.getProductPath = getProductPath;
+const getCategoriesByRoute = (product, route) => {
+  if (!product) {
+    return [];
+  }
+  const item = product?.categories?.find(categories => {
+    return categories.some(entry => entry.categoryUrl === route?.path);
+  });
+  if (item) {
+    return item;
+  }
+  return product.categories?.[product.categories?.length - 1] || [];
+};
+exports.getCategoriesByRoute = getCategoriesByRoute;
+const getLatestCategory = categories => {
+  if (!categories || categories.length === 0) {
+    return;
+  }
+  const categoriesLength = categories.length;
+  const latestSubset = categories[categoriesLength - 1];
+  return latestSubset[latestSubset.length - 1];
+};
+exports.getLatestCategory = getLatestCategory;
+const getProductAndSiblingsColors = (product, colorAttributeName = "colorDetail") => {
+  const productColor = (0, _backbone.getFirstAttributeValue)(product.attributes, colorAttributeName);
+  const siblingsColors = product.siblings?.filter(sibling => sibling.isActive && !sibling.isSoldOut).map(sibling => (0, _backbone.getFirstAttributeValue)(sibling.attributes, colorAttributeName));
+  return [productColor, ...(siblingsColors || [])].filter(color => !!color);
+};
+exports.getProductAndSiblingsColors = getProductAndSiblingsColors;
+const getVariantCrosssellingValues = variants => {
+  if (!variants?.length) {
+    return [];
+  }
+  const crossellings = variants.map(variant => variant.advancedAttributes?.variantCrosssellings).filter(Boolean);
+  const uniqueCrossellings = (0, _radash.unique)(crossellings, it => it?.id);
+  const values = uniqueCrossellings.map(r => r?.values);
+  const fieldSets = (0, _arrayHelpers.flattenDeep)(values).map(r => r?.fieldSet);
+  return (0, _arrayHelpers.flattenDeep)(fieldSets).map(r => r?.value).filter(it => !!it);
+};
+exports.getVariantCrosssellingValues = getVariantCrosssellingValues;

package/dist/helpers/productHelpers.d.ts

@@ -0,0 +1,41 @@
+import { BasketItemPrice } from '@aboutyou/backbone';
+import type { AppliedReduction, BapiPrice as Price, BapiProduct as Product, Value, Variant } from '@aboutyou/backbone/types/BapiProduct';
+import { ProductSibling } from '../types/bapi/product';
+interface Route {
+    path?: string;
+}
+export declare const slugify: (url: string | undefined) => string;
+export declare const getPrice: (variant: Variant) => Price;
+type BadgeLabelParamsKeys = 'isNew' | 'isSoldOut' | 'isOnlineOnly' | 'isSustainable' | 'isPremium';
+type BadgeLabelParams = Partial<Record<BadgeLabelParamsKeys, boolean>>;
+export declare const getBadgeLabel: (params?: BadgeLabelParams) => string;
+export declare const getOriginalPrice: (price: Price) => number;
+export declare const getTotalAppliedReductions: (price: {
+    appliedReductions: {
+        amount: {
+            absoluteWithTax: number;
+            relative: number;
+        };
+    }[];
+}) => {
+    absoluteWithTax: number;
+    relative: number;
+};
+export declare const getLowestPrice: (variants: Variant[]) => Price;
+export declare const getAppliedReductionsByCategory: (price: Price | BasketItemPrice, category: AppliedReduction['category']) => AppliedReduction[];
+export declare const getSizeFromSpecificVariant: (product: Product, variantId?: number) => Value | null | undefined;
+export declare const getVariant: (variants: Variant[], id: number) => Variant | undefined;
+export declare const getSizeFromVariant: (variant: Variant, attributeName?: string) => Value | undefined;
+export declare const getAllSizesFromVariants: (variantsAttributes: Variant[], attributeName?: string) => (Value | undefined)[];
+export declare const getProductSiblings: (product?: Product | null, colorAttributeName?: string) => ProductSibling[];
+export declare const getProductColors: (product: Product, colorAttributeName?: string) => string[];
+export declare const getVariantBySize: (variants: Variant[], size: Value, sizeAttributeName?: string) => Variant | undefined;
+export declare const isInStock: (variant: Variant) => boolean;
+export declare const isVariantInStock: (variants: Variant[], size: Value, sizeAttributeName?: string) => boolean;
+export declare const getAttribute: (product: Product, key: string) => any;
+export declare const getProductPath: (product: Product) => string;
+export declare const getCategoriesByRoute: (product: Product | null, route: Route | null) => import("@aboutyou/backbone").BapiProductCategory[];
+export declare const getLatestCategory: (categories?: Product['categories']) => import("@aboutyou/backbone").BapiProductCategory | undefined;
+export declare const getProductAndSiblingsColors: (product: Product, colorAttributeName?: string) => Value[];
+export declare const getVariantCrosssellingValues: (variants: Variant[] | undefined) => (string | number)[];
+export {};

package/dist/helpers/productHelpers.mjs

@@ -0,0 +1,170 @@
+import { getFirstAttributeValue } from "@aboutyou/backbone";
+import { unique } from "radash";
+import baseSlugify from "slugify";
+import { ProductImageType } from "../constants/product.mjs";
+import { getAttributeValue, getAttributeValueTuples } from "./attributeHelpers.mjs";
+import { getImageFromList } from "./imageHelpers.mjs";
+import { flattenDeep } from "./arrayHelpers.mjs";
+export const slugify = (url) => {
+  return baseSlugify(url ?? "", {
+    lower: true,
+    remove: /[*+~.()'"!:@/#?]/g
+  });
+};
+const BadgeLabel = {
+  NEW: "new",
+  SOLD_OUT: "sold_out",
+  ONLINE_EXCLUSIVE: "online_exclusive",
+  SUSTAINABLE: "sustainable",
+  PREMIUM: "premium",
+  DEFAULT: ""
+};
+export const getPrice = (variant) => variant.price;
+export const getBadgeLabel = (params = {}) => {
+  if (!params) {
+    return BadgeLabel.DEFAULT;
+  }
+  const { isNew, isSoldOut, isOnlineOnly, isSustainable, isPremium } = params;
+  if (isNew) {
+    return BadgeLabel.NEW;
+  } else if (isSoldOut) {
+    return BadgeLabel.SOLD_OUT;
+  } else if (isOnlineOnly) {
+    return BadgeLabel.ONLINE_EXCLUSIVE;
+  } else if (isSustainable) {
+    return BadgeLabel.SUSTAINABLE;
+  } else if (isPremium) {
+    return BadgeLabel.PREMIUM;
+  } else {
+    return BadgeLabel.DEFAULT;
+  }
+};
+export const getOriginalPrice = (price) => {
+  return price.appliedReductions.length > 0 ? price.appliedReductions[0].amount.absoluteWithTax + price.withTax : price.withTax;
+};
+export const getTotalAppliedReductions = (price) => {
+  const total = { absoluteWithTax: 0, relative: 0 };
+  if (price) {
+    price.appliedReductions.forEach((reduction) => {
+      total.absoluteWithTax += reduction.amount.absoluteWithTax;
+      total.relative += reduction.amount.relative;
+    });
+  }
+  return total;
+};
+export const getLowestPrice = (variants) => {
+  return variants.reduce(
+    (m, x) => m.price.withoutTax < x.price.withoutTax ? m : x
+  ).price;
+};
+export const getAppliedReductionsByCategory = (price, category) => {
+  return price.appliedReductions.filter((reduction) => {
+    return reduction.category === category;
+  });
+};
+export const getSizeFromSpecificVariant = (product, variantId) => {
+  if (!product.variants) {
+    return null;
+  }
+  const variant = product.variants?.find((item) => item.id === variantId);
+  return getSizeFromVariant(variant || product.variants[0]);
+};
+export const getVariant = (variants, id) => {
+  return variants?.find((variant) => variant.id === id);
+};
+export const getSizeFromVariant = (variant, attributeName = "shopSize") => getFirstAttributeValue(variant.attributes, attributeName);
+export const getAllSizesFromVariants = (variantsAttributes, attributeName = "shopSize") => unique(
+  variantsAttributes.map(
+    (variant) => getFirstAttributeValue(variant.attributes, attributeName)
+  ).filter(Boolean),
+  (it) => it?.id
+);
+export const getProductSiblings = (product, colorAttributeName = "colorDetail") => {
+  if (!product) {
+    return [];
+  }
+  const items = [product];
+  product.siblings?.forEach((item) => {
+    if (!item.isActive) {
+      return;
+    }
+    items.push(item);
+  });
+  return items.map((item) => ({
+    id: item.id,
+    image: getImageFromList(item.images, ProductImageType.BUST, "front"),
+    colors: getAttributeValueTuples(item.attributes, colorAttributeName)
+  }));
+};
+export const getProductColors = (product, colorAttributeName = "colorDetail") => {
+  return getAttributeValueTuples(product.attributes, colorAttributeName).map(
+    (color) => color.label
+  );
+};
+export const getVariantBySize = (variants, size, sizeAttributeName = "shopSize") => {
+  return variants?.find(
+    (variant) => getAttributeValue(variant.attributes, sizeAttributeName) === size.value
+  );
+};
+export const isInStock = (variant) => {
+  return variant.stock.quantity > 0 || variant.stock.isSellableWithoutStock === true;
+};
+export const isVariantInStock = (variants, size, sizeAttributeName = "shopSize") => {
+  const variant = variants?.find(
+    (variant2) => getSizeFromVariant(variant2, sizeAttributeName)?.value === size.value
+  );
+  if (!variant) {
+    return false;
+  }
+  return isInStock(variant);
+};
+export const getAttribute = (product, key) => {
+  const values = product.attributes?.[key]?.values;
+  return values?.value ?? values?.label;
+};
+export const getProductPath = (product) => {
+  const name = getAttributeValue(product.attributes, "name");
+  return `/product/${slugify(name)}-${product.id}`;
+};
+export const getCategoriesByRoute = (product, route) => {
+  if (!product) {
+    return [];
+  }
+  const item = product?.categories?.find((categories) => {
+    return categories.some((entry) => entry.categoryUrl === route?.path);
+  });
+  if (item) {
+    return item;
+  }
+  return product.categories?.[product.categories?.length - 1] || [];
+};
+export const getLatestCategory = (categories) => {
+  if (!categories || categories.length === 0) {
+    return;
+  }
+  const categoriesLength = categories.length;
+  const latestSubset = categories[categoriesLength - 1];
+  return latestSubset[latestSubset.length - 1];
+};
+export const getProductAndSiblingsColors = (product, colorAttributeName = "colorDetail") => {
+  const productColor = getFirstAttributeValue(
+    product.attributes,
+    colorAttributeName
+  );
+  const siblingsColors = product.siblings?.filter((sibling) => sibling.isActive && !sibling.isSoldOut).map(
+    (sibling) => getFirstAttributeValue(sibling.attributes, colorAttributeName)
+  );
+  return [productColor, ...siblingsColors || []].filter(
+    (color) => !!color
+  );
+};
+export const getVariantCrosssellingValues = (variants) => {
+  if (!variants?.length) {
+    return [];
+  }
+  const crossellings = variants.map((variant) => variant.advancedAttributes?.variantCrosssellings).filter(Boolean);
+  const uniqueCrossellings = unique(crossellings, (it) => it?.id);
+  const values = uniqueCrossellings.map((r) => r?.values);
+  const fieldSets = flattenDeep(values).map((r) => r?.fieldSet);
+  return flattenDeep(fieldSets).map((r) => r?.value).filter((it) => !!it);
+};

package/dist/helpers/sanitizationHelpers.cjs

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.stripShopLocaleFromPath = exports.sanitize = void 0;
+var _isomorphicDompurify = _interopRequireDefault(require("isomorphic-dompurify"));
+var _radash = require("radash");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const sanitize = payload => {
+  return (0, _radash.mapValues)(payload, value => value && _isomorphicDompurify.default.sanitize(value));
+};
+exports.sanitize = sanitize;
+const stripShopLocaleFromPath = (locale, path, splitter = "/") => path.split(splitter).filter(segment => segment.toLowerCase() !== locale.toLowerCase()).join("/");
+exports.stripShopLocaleFromPath = stripShopLocaleFromPath;

package/dist/helpers/sanitizationHelpers.d.ts

@@ -0,0 +1,2 @@
+export declare const sanitize: <T extends Record<string, string | undefined>>(payload: T) => Record<string, any>;
+export declare const stripShopLocaleFromPath: (locale: string, path: string, splitter?: string) => string;

package/dist/helpers/sanitizationHelpers.mjs

@@ -0,0 +1,6 @@
+import DOMPurify from "isomorphic-dompurify";
+import { mapValues } from "radash";
+export const sanitize = (payload) => {
+  return mapValues(payload, (value) => value && DOMPurify.sanitize(value));
+};
+export const stripShopLocaleFromPath = (locale, path, splitter = "/") => path.split(splitter).filter((segment) => segment.toLowerCase() !== locale.toLowerCase()).join("/");

package/dist/helpers/sortingHelper.cjs

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSortingValues = exports.getSortByValue = void 0;
+var _backbone = require("@aboutyou/backbone");
+var _radash = require("radash");
+var _sorting = require("../constants/sorting.cjs");
+const SORTING_VALUES = {
+  topSeller: {
+    by: _backbone.APISortOption.Price,
+    direction: _backbone.APISortOrder.Descending,
+    name: _sorting.SortName.TOPSELLER,
+    query: _sorting.SortQuery.TOPSELLER
+  },
+  dateNewest: {
+    by: _backbone.APISortOption.DateAdded,
+    name: _sorting.SortName.DATE_NEWEST,
+    query: _sorting.SortQuery.DATE_NEWEST
+  },
+  priceDesc: {
+    by: _backbone.APISortOption.Price,
+    direction: _backbone.APISortOrder.Descending,
+    name: _sorting.SortName.PRICE_DESC,
+    query: _sorting.SortQuery.PRICE_DESC
+  },
+  priceAsc: {
+    by: _backbone.APISortOption.Price,
+    direction: _backbone.APISortOrder.Ascending,
+    name: _sorting.SortName.PRICE_ASC,
+    query: _sorting.SortQuery.PRICE_ASC
+  },
+  reductionDesc: {
+    by: _backbone.APISortOption.Reduction,
+    direction: _backbone.APISortOrder.Descending,
+    name: _sorting.SortName.REDUCTION_DESC,
+    query: _sorting.SortQuery.REDUCTION_DESC
+  },
+  reductionAsc: {
+    by: _backbone.APISortOption.Reduction,
+    direction: _backbone.APISortOrder.Ascending,
+    name: _sorting.SortName.REDUCTION_ASC,
+    query: _sorting.SortQuery.REDUCTION_ASC
+  }
+};
+const getSortingValues = (options = ["topSeller", "dateNewest", "priceDesc", "priceAsc", "reductionDesc", "reductionAsc"]) => (0, _radash.pick)(SORTING_VALUES, options);
+exports.getSortingValues = getSortingValues;
+const getSortByValue = (query, defaultSort) => {
+  switch (query) {
+    case _sorting.SortQuery.PRICE_DESC:
+      return SORTING_VALUES.priceDesc;
+    case _sorting.SortQuery.PRICE_ASC:
+      return SORTING_VALUES.priceAsc;
+    case _sorting.SortQuery.REDUCTION_DESC:
+      return SORTING_VALUES.reductionDesc;
+    case _sorting.SortQuery.REDUCTION_ASC:
+      return SORTING_VALUES.reductionAsc;
+    case _sorting.SortQuery.TOPSELLER:
+      return SORTING_VALUES.topSeller;
+    case _sorting.SortQuery.DATE_NEWEST:
+      return SORTING_VALUES.dateNewest;
+    default:
+      return SORTING_VALUES[defaultSort || "dateNewest"];
+  }
+};
+exports.getSortByValue = getSortByValue;

package/dist/helpers/sortingHelper.d.ts

@@ -0,0 +1,69 @@
+import { APISortOption, APISortOrder } from '@aboutyou/backbone';
+import type { Query, SortingValueKey } from '../index';
+export declare const getSortingValues: (options?: Array<SortingValueKey>) => Pick<{
+    topSeller: {
+        by: APISortOption;
+        direction: APISortOrder;
+        name: "topseller";
+        query: "topseller";
+    };
+    dateNewest: {
+        by: APISortOption;
+        name: "date_newest";
+        query: "date-newest";
+    };
+    priceDesc: {
+        by: APISortOption;
+        direction: APISortOrder;
+        name: "price_desc";
+        query: "price-desc";
+    };
+    priceAsc: {
+        by: APISortOption;
+        direction: APISortOrder;
+        name: "price_asc";
+        query: "price-asc";
+    };
+    reductionDesc: {
+        by: APISortOption;
+        direction: APISortOrder;
+        name: "reduction_desc";
+        query: "reduction-desc";
+    };
+    reductionAsc: {
+        by: APISortOption;
+        direction: APISortOrder;
+        name: "reduction_asc";
+        query: "reduction-asc";
+    };
+}, SortingValueKey>;
+export declare const getSortByValue: (query: Query, defaultSort?: SortingValueKey) => {
+    by: APISortOption;
+    direction: APISortOrder;
+    name: "topseller";
+    query: "topseller";
+} | {
+    by: APISortOption;
+    name: "date_newest";
+    query: "date-newest";
+} | {
+    by: APISortOption;
+    direction: APISortOrder;
+    name: "price_desc";
+    query: "price-desc";
+} | {
+    by: APISortOption;
+    direction: APISortOrder;
+    name: "price_asc";
+    query: "price-asc";
+} | {
+    by: APISortOption;
+    direction: APISortOrder;
+    name: "reduction_desc";
+    query: "reduction-desc";
+} | {
+    by: APISortOption;
+    direction: APISortOrder;
+    name: "reduction_asc";
+    query: "reduction-asc";
+};