@ikas/storefront-model-functions 4.0.0-alpha.10

package/src/functions/product/filter/index.ts

@@ -0,0 +1,197 @@
+import {
+  IkasApplicableProductFilterValue,
+  IkasFilterRangeValue,
+  IkasProductFilter,
+  IkasProductFilterDisplayType,
+  IkasProductFilterNumberRangeListOption,
+  IkasProductFilterSortType,
+  IkasProductFilterType,
+} from "@ikas/storefront-models";
+import _sortBy from "lodash/sortBy";
+import _cloneDeep from "lodash/cloneDeep";
+
+export function isCustomValueFilter(filter: IkasProductFilter) {
+  return [
+    IkasProductFilterDisplayType.NUMBER_RANGE_LIST,
+    IkasProductFilterDisplayType.NUMBER_RANGE,
+  ].includes(filter.displayType);
+}
+
+export function isStockFilter(filter: IkasProductFilter) {
+  return filter.type === IkasProductFilterType.STOCK_STATUS;
+}
+
+export function getValueList(filter: IkasProductFilter) {
+  if (filter.numberRange) return [rangeToId(filter.numberRange)];
+  if (filter.numberRangeListOptions)
+    return filter.numberRangeListOptions
+      .filter((o) => o.isSelected)
+      .map((o) => rangeToId(o));
+
+  return filter.values?.filter((v) => v.isSelected).map((v) => v.id) || [];
+}
+
+export function getKeyList(filter: IkasProductFilter) {
+  if (filter.numberRange) return [rangeToId(filter.numberRange)];
+  if (filter.numberRangeListOptions)
+    return filter.numberRangeListOptions
+      .filter((o) => o.isSelected)
+      .map((o) => rangeToId(o));
+
+  return filter.values?.filter((v) => v.isSelected).map((v) => v.key) || [];
+}
+
+export function getDisplayedValues(filter: IkasProductFilter) {
+  const sortType =
+    filter.settings?.sortType || IkasProductFilterSortType.ALPHABETICAL_ASC;
+
+  const isDesc = [
+    IkasProductFilterSortType.ALPHABETICAL_DESC,
+    IkasProductFilterSortType.PRODUCT_COUNT_DESC,
+  ].includes(sortType);
+  const isAlphabetical = [
+    IkasProductFilterSortType.ALPHABETICAL_ASC,
+    IkasProductFilterSortType.ALPHABETICAL_DESC,
+  ].includes(sortType);
+
+  let _values = filter.values?.filter((v) =>
+    v.resultCount === 0 ? v.isSelected : true
+  );
+
+  if (isAlphabetical) _values = _sortBy(_values, "name");
+  else _values = _sortBy(_values, "resultCount");
+
+  if (isDesc) _values = _values?.reverse();
+
+  return _values;
+}
+
+export function onFilterValueClick(
+  filter: IkasProductFilter,
+  filterValue: IkasApplicableProductFilterValue
+) {
+  if (isCustomValueFilter(filter)) {
+    throw new Error(
+      "onFilterValueClick cannot be used with NUMBER_RANGE | NUMBER_RANGE_LIST types!"
+    );
+  }
+
+  filterValue.isSelected = !filterValue.isSelected;
+
+  if (!filter.isMultiSelect && filterValue.isSelected) {
+    filter.values?.forEach((fv) => {
+      if (fv.id !== filterValue.id) (fv as any)._isSelected = false;
+    });
+  }
+}
+
+export function onNumberRangeClick(
+  filter: IkasProductFilter,
+  option: IkasProductFilterNumberRangeListOption
+) {
+  if (filter.displayType !== IkasProductFilterDisplayType.NUMBER_RANGE_LIST)
+    throw new Error(
+      "onNumberRangeClick can only be used with NUMBER_RANGE filters!"
+    );
+
+  (option as any)._isSelected = !option.isSelected;
+
+  if (!filter.isMultiSelect && option.isSelected) {
+    filter.numberRangeListOptions?.forEach((nro) => {
+      if (nro.key !== option.key) (nro as any)._isSelected = false;
+    });
+  }
+}
+
+export function onNumberRangeChange(
+  filter: IkasProductFilter,
+  numberRange: IkasFilterRangeValue | null
+) {
+  if (filter.displayType !== IkasProductFilterDisplayType.NUMBER_RANGE)
+    throw new Error(
+      "onNumberRangeChange can only be used with NUMBER_RANGE filters!"
+    );
+
+  if (!numberRange) {
+    filter.numberRange = null;
+    return;
+  }
+
+  const newRange = _cloneDeep(numberRange);
+  if (newRange.from < filter.numberRangeLimit!.from)
+    newRange.from = filter.numberRange!.from;
+  if (
+    newRange.to &&
+    filter.numberRangeLimit?.to &&
+    newRange.to > filter.numberRangeLimit.to
+  )
+    newRange.to = filter.numberRangeLimit.to;
+
+  filter.numberRange = newRange;
+}
+
+export function clear(filter: IkasProductFilter) {
+  filter.numberRange = null;
+  filter.numberRangeListOptions?.forEach(
+    (o) => ((o as any)._isSelected = false)
+  );
+  filter.values?.forEach((v) => ((v as any)._isSelected = false));
+}
+
+export function toInput(
+  filter: IkasProductFilter
+): IkasSearchInputFilterListInput {
+  return {
+    id: filter.key,
+    type: filter.type as any,
+    valueList: getValueList(filter),
+    useAndFilter: filter.settings?.useAndFilter,
+  };
+}
+
+export function applyQueryParam(filter: IkasProductFilter, value: string) {
+  const valueKeys = value.split(",");
+
+  if (filter.displayType === IkasProductFilterDisplayType.NUMBER_RANGE) {
+    filter.numberRange = parseRangeStr(value);
+  } else if (
+    filter.displayType === IkasProductFilterDisplayType.NUMBER_RANGE_LIST
+  ) {
+    filter.numberRangeListOptions?.forEach((o) => {
+      if (valueKeys.includes(o.key)) (o as any)._isSelected = true;
+    });
+  } else {
+    filter.values?.forEach((filterValue) => {
+      if (valueKeys.includes(filterValue.key) && filterValue.resultCount !== 0)
+        (filterValue as any)._isSelected = true;
+    });
+  }
+}
+
+export function rangeToId(range: IkasFilterRangeValue) {
+  return `${range.from}:${range.to || ""}`;
+}
+
+export function parseRangeStr(rangeStr: string): IkasFilterRangeValue {
+  try {
+    const parsedValues = rangeStr.split(":").map((i) => parseInt(i));
+    return {
+      from: isNaN(parsedValues[0]) ? 0 : parsedValues[0],
+      to: isNaN(parsedValues[1]) ? undefined : parsedValues[1],
+    };
+  } catch (err) {
+    console.log(err);
+    return {
+      from: 0,
+      to: 0,
+    };
+  }
+}
+
+export type IkasSearchInputFilterListInput = {
+  displayType?: IkasProductFilterDisplayType | null;
+  id: string;
+  type: IkasProductFilterType;
+  useAndFilter?: boolean | null;
+  valueList: string[];
+};

package/src/functions/product/index.ts

@@ -0,0 +1,145 @@
+import {
+  IkasDisplayedVariantType,
+  IkasDisplayedVariantValue,
+  IkasProduct,
+  IkasProductOptionSet,
+  IkasProductVariant,
+  IkasVariantValue,
+} from "@ikas/storefront-models";
+import { getIkasVariantTypeSlug } from "../variant-type";
+import { getIkasVariantValueSlug } from "../variant-type/variant-value";
+import { hasValidValues as hasValidProductOptionSetValues } from "./option-set";
+import { hasStock as hasVariantStock } from "./variant/index";
+
+export function hasVariant(product: IkasProduct) {
+  return !!product.variantTypes.length;
+}
+
+export function hasStock(product: IkasProduct) {
+  return product.variants.some((v) => v.stock > 0);
+}
+
+export function getMainVariantValue(selectedVariantValues: IkasVariantValue[]) {
+  return selectedVariantValues.length ? selectedVariantValues[0] : undefined;
+}
+
+export function getMainVariantType(product: IkasProduct) {
+  if (!hasVariant(product)) return;
+  return product.variantTypes[0].variantType;
+}
+
+export function getSelectedVariantHref(
+  product: IkasProduct,
+  selectedVariantValues: IkasVariantValue[]
+) {
+  const metaData = product.metaData;
+  if (!metaData?.slug) return "";
+
+  const variantParams = product.variantTypes
+    .map((pvt) => {
+      const vt = pvt.variantType;
+      const selectedVariantValue = vt.values.find((vv) =>
+        selectedVariantValues.some((svv) => svv.id === vv.id)
+      );
+
+      if (selectedVariantValue)
+        return `${getIkasVariantTypeSlug(vt)}=${getIkasVariantValueSlug(
+          selectedVariantValue
+        )}`;
+    })
+    .filter((param) => !!param)
+    .join("&");
+
+  if (variantParams) return `/${metaData!.slug}?${variantParams}`;
+  else return `/${metaData!.slug}`;
+}
+
+export function getProductHref(product: IkasProduct) {
+  const metaData = product.metaData;
+  if (!metaData?.slug) return "";
+
+  return `/${metaData.slug}`;
+}
+
+export function getDisplayedVariantTypes(
+  product: IkasProduct,
+  selectedVariantValues: IkasVariantValue[]
+): IkasDisplayedVariantType[] {
+  const displayedVariantTypes = product.variantTypes.map(
+    (productVariantType, index) => {
+      const variantType = productVariantType.variantType;
+      const displayedVariantValues: IkasDisplayedVariantValue[] = [];
+
+      const parentProductVariantTypes =
+        index > 0 ? product.variantTypes.slice(0, index) : null;
+      let parentSelectedVariantValues: IkasVariantValue[] = [];
+
+      if (parentProductVariantTypes) {
+        parentSelectedVariantValues = selectedVariantValues.filter((vv) =>
+          parentProductVariantTypes.some(
+            (pvt) => pvt.variantType.id === vv.variantTypeId
+          )
+        );
+      }
+
+      variantType.values.forEach((variantValue) => {
+        const variantValues = [...parentSelectedVariantValues, variantValue];
+        const variant = product.variants.find(
+          (variant) =>
+            variant.isActive &&
+            variantValues.every((vv) =>
+              variant.variantValues.some((vvv) => vvv.id === vv.id)
+            )
+        );
+        const variantWithStock = product.variants.find(
+          (variant) =>
+            variant.isActive &&
+            hasVariantStock(variant) &&
+            variantValues.every((vv) =>
+              variant.variantValues.some((vvv) => vvv.id === vv.id)
+            )
+        );
+        const isSelected = selectedVariantValues.some(
+          (vv) => vv.id === variantValue.id
+        );
+
+        if (variant) {
+          displayedVariantValues.push({
+            variant,
+            variantValue,
+            hasStock: !!variantWithStock,
+            isSelected,
+          });
+        }
+      });
+
+      return {
+        variantType,
+        displayedVariantValues,
+      };
+    }
+  );
+
+  // Filter inactive variantValues if there is only a single variant type
+  if (displayedVariantTypes.length === 1) {
+    displayedVariantTypes[0].displayedVariantValues =
+      displayedVariantTypes[0].displayedVariantValues.filter(
+        (dvv) => dvv.variant.isActive
+      );
+  }
+
+  return displayedVariantTypes;
+}
+
+export function isAddToCartEnabled(
+  selectedVariant: IkasProductVariant,
+  productOptionSet?: IkasProductOptionSet
+) {
+  const _hasValidProductOptionValues = productOptionSet
+    ? hasValidProductOptionSetValues(productOptionSet)
+    : true;
+  return (
+    _hasValidProductOptionValues &&
+    (hasVariantStock(selectedVariant) || selectedVariant.sellIfOutOfStock)
+  );
+}

package/src/functions/product/option-set/index.ts

@@ -0,0 +1,19 @@
+import { IkasProductOptionSet } from "@ikas/storefront-models";
+import _sortBy from "lodash/sortBy";
+import { initValues } from "./option";
+import { hasValidValues as hasValidOptionValues } from "./option";
+
+export function getDisplayedOptions(optionSet: IkasProductOptionSet) {
+  return _sortBy(
+    optionSet.options.filter((o) => !o.requiredOptionId),
+    "order"
+  );
+}
+
+export function initOptionValues(optionSet: IkasProductOptionSet) {
+  optionSet.options.forEach((o) => initValues(o));
+}
+
+export function hasValidValues(optionSet: IkasProductOptionSet) {
+  return getDisplayedOptions(optionSet).every(hasValidOptionValues);
+}

package/src/functions/product/option-set/option/index.ts

@@ -0,0 +1,189 @@
+import {
+  IkasProductOption,
+  IkasProductOptionType,
+} from "@ikas/storefront-models";
+import _sortBy from "lodash/sortBy";
+
+export function getDisplayedChildOptions(option: IkasProductOption) {
+  return _sortBy(
+    option.childOptions.filter((co) => {
+      // Check if all required options are selected
+      if (co.requiredOptionValueIds?.length) {
+        return co.requiredOptionValueIds.every((rovId) =>
+          option.values.some((v) => v === rovId)
+        );
+      } else {
+        if (option.type === IkasProductOptionType.CHECKBOX) {
+          return !!option.values.length && option.values[0] === "true";
+        }
+        return !!option.values.length;
+      }
+    }),
+    "order"
+  );
+}
+
+export function hasValidValues(option: IkasProductOption): boolean {
+  if (!option.values.length && !option.isOptional) {
+    return false;
+  }
+
+  let _hasValidValues = false;
+
+  switch (option.type) {
+    case IkasProductOptionType.TEXT:
+    case IkasProductOptionType.TEXT_AREA:
+      _hasValidValues = isValidTextOptionValue(option);
+      break;
+
+    case IkasProductOptionType.CHECKBOX:
+    case IkasProductOptionType.COLOR_PICKER:
+      _hasValidValues = true;
+      break;
+
+    case IkasProductOptionType.CHOICE:
+      _hasValidValues = isValidChoiceOptionValue(option);
+      break;
+
+    case IkasProductOptionType.DATE_PICKER:
+      _hasValidValues = isValidDateOptionValue(option);
+      break;
+
+    case IkasProductOptionType.FILE:
+      _hasValidValues = isValidFileOptionValue(option);
+      break;
+
+    default:
+      break;
+  }
+
+  return (
+    _hasValidValues &&
+    getDisplayedChildOptions(option).every((co) => hasValidValues(co))
+  );
+}
+
+export function setValues(option: IkasProductOption, values: string[]) {
+  option.values = values;
+  if (!values.length) {
+    option.childOptions.forEach((co) => (co.values = []));
+  }
+}
+
+export function initValues(option: IkasProductOption) {
+  if (!option.isOptional) {
+    option.values = [];
+    if (option.childOptions) {
+      option.childOptions.forEach((co) => initValues(co));
+    }
+  }
+}
+
+function isValidTextOptionValue(option: IkasProductOption) {
+  const value = option.values[0];
+  if (!value) {
+    return !!option.isOptional;
+  }
+
+  return (
+    !!option.textSettings &&
+    (option.textSettings.min !== null
+      ? value.length >= option.textSettings.min
+      : true) &&
+    (option.textSettings.max !== null
+      ? value.length <= option.textSettings.max
+      : true)
+  );
+}
+
+function isValidChoiceOptionValue(option: IkasProductOption) {
+  if (!option.values.length) {
+    return !!option.isOptional;
+  }
+
+  return (
+    !!option.selectSettings &&
+    (option.selectSettings.minSelect !== null
+      ? option.values.length >= option.selectSettings.minSelect
+      : true) &&
+    (option.selectSettings.maxSelect !== null
+      ? option.values.length <= option.selectSettings.maxSelect
+      : true)
+  );
+}
+
+function isValidFileOptionValue(option: IkasProductOption) {
+  if (!option.values.length) {
+    return !!option.isOptional;
+  }
+
+  return (
+    !!option.fileSettings &&
+    (option.fileSettings.minQuantity !== null
+      ? option.values.length >= option.fileSettings.minQuantity
+      : true) &&
+    (option.fileSettings.maxQuantity !== null
+      ? option.values.length <= option.fileSettings.maxQuantity
+      : true)
+  );
+}
+
+function isValidDateOptionValue(option: IkasProductOption) {
+  if (!option.values.length) {
+    return !!option.isOptional;
+  }
+
+  if (!!option.dateSettings) {
+    let minDate: Date | null = null;
+    let maxDate: Date | null = null;
+
+    if (option.dateSettings.minRelativeNextDate !== null) {
+      minDate = new Date();
+      if (option.dateSettings.minRelativeNextDate < 0) {
+        minDate = new Date(
+          minDate.setDate(
+            minDate.getDate() -
+              Math.abs(option.dateSettings.minRelativeNextDate)
+          )
+        );
+      } else {
+        minDate = new Date(
+          minDate.setDate(
+            minDate.getDate() +
+              Math.abs(option.dateSettings.minRelativeNextDate)
+          )
+        );
+      }
+
+      minDate = new Date(minDate.setHours(23, 59, 0));
+    }
+
+    if (option.dateSettings.maxRelativeNextDate !== null) {
+      maxDate = new Date();
+      if (option.dateSettings.maxRelativeNextDate < 0) {
+        maxDate = new Date(
+          maxDate.setDate(
+            maxDate.getDate() -
+              Math.abs(option.dateSettings.maxRelativeNextDate)
+          )
+        );
+      } else {
+        maxDate = new Date(
+          maxDate.setDate(
+            maxDate.getDate() +
+              Math.abs(option.dateSettings.maxRelativeNextDate)
+          )
+        );
+      }
+
+      maxDate = new Date(maxDate.setHours(23, 59, 59));
+    }
+
+    const value = new Date(new Date(option.values[0]).setHours(23, 59, 59));
+
+    return (
+      (minDate ? value.getTime() >= minDate.getTime() : true) &&
+      (maxDate ? value.getTime() <= maxDate.getTime() : true)
+    );
+  } else return true;
+}

package/src/functions/product/variant/index.ts

@@ -0,0 +1,9 @@
+import { IkasProductVariant } from "@ikas/storefront-models";
+
+export function getMainImage(variant: IkasProductVariant) {
+  return variant.images?.length ? variant.images[0] : undefined;
+}
+
+export function hasStock(variant: IkasProductVariant) {
+  return variant.stock > 0;
+}

package/src/functions/product/variant/price/index.ts

@@ -0,0 +1,20 @@
+import { IkasProductPrice } from "@ikas/storefront-models";
+
+export function getFinalPrice(price: IkasProductPrice) {
+  return price.discountPrice !== null ? price.discountPrice : price.sellPrice;
+}
+
+export function hasDiscount(price: IkasProductPrice) {
+  return price.discountPrice !== null;
+}
+
+export function getDiscountAmount(price: IkasProductPrice) {
+  if (hasDiscount(price)) return price.sellPrice - price.discountPrice!;
+  return 0;
+}
+
+export function getDiscountPercentage(price: IkasProductPrice) {
+  if (hasDiscount(price))
+    return (100 - (getFinalPrice(price) * 100) / price.sellPrice).toFixed(0);
+  return 0;
+}

package/src/functions/raffle/index.ts

@@ -0,0 +1,14 @@
+import { IkasRaffle } from "@ikas/storefront-models";
+
+export function isRaffleAvailable(raffle: IkasRaffle) {
+  if (!raffle.status) return false;
+
+  const now = Date.now();
+
+  return (
+    raffle.dateRange?.start &&
+    now > raffle.dateRange.start &&
+    raffle.dateRange.end &&
+    now < raffle.dateRange.end
+  );
+}

package/src/functions/variant-type/index.ts

@@ -0,0 +1,13 @@
+import {
+  IkasVariantSelectionType,
+  IkasVariantType,
+} from "@ikas/storefront-models";
+import { stringToSlug } from "../../utils/helper";
+
+export function isColorSelection(variantType: IkasVariantType) {
+  return variantType.selectionType === IkasVariantSelectionType.COLOR;
+}
+
+export function getIkasVariantTypeSlug(variantType: IkasVariantType) {
+  return stringToSlug(variantType.name);
+}

package/src/functions/variant-type/variant-value/index.ts

@@ -0,0 +1,13 @@
+import { IkasImage, IkasVariantValue } from "@ikas/storefront-models";
+import { stringToSlug } from "../../../utils/helper";
+
+export function getIkasVariantValueSlug(variantValue: IkasVariantValue) {
+  return stringToSlug(variantValue.name);
+}
+
+export function getThumbnailImage(
+  variantValue: IkasVariantValue
+): IkasImage | undefined {
+  if (variantValue.thumbnailImageId)
+    return { id: variantValue.thumbnailImageId, isVideo: false };
+}