@ikas/storefront 4.0.0-alpha.59 → 4.0.0-alpha.6

package/src/store/location/index.ts

@@ -0,0 +1,56 @@
+import {
+  getMyCountry,
+  listCountry,
+  ListCountryQueryParams,
+  APIResponse,
+  ListCityQueryParams,
+  listCity,
+  ListDistrictQueryParams,
+  listDistrict,
+  ListStateQueryParams,
+  listState,
+} from "@ikas/storefront-api";
+import {
+  IkasCity,
+  IkasCountry,
+  IkasDistrict,
+  IkasState,
+} from "../../models/data";
+
+export default class LocationStore {
+  static async getMyCountry() {
+    return await getMyCountry();
+  }
+
+  static async listCountry(params: ListCountryQueryParams) {
+    const response = await listCountry(params);
+    return new APIResponse(
+      response.data?.map((d) => new IkasCountry(d)),
+      response.graphQLErrors
+    );
+  }
+
+  static async listCity(params: ListCityQueryParams) {
+    const response = await listCity(params);
+    return new APIResponse(
+      response.data?.map((d) => new IkasCity(d)),
+      response.graphQLErrors
+    );
+  }
+
+  static async listDistrict(params: ListDistrictQueryParams) {
+    const response = await listDistrict(params);
+    return new APIResponse(
+      response.data?.map((d) => new IkasDistrict(d)),
+      response.graphQLErrors
+    );
+  }
+
+  static async listState(params: ListStateQueryParams) {
+    const response = await listState(params);
+    return new APIResponse(
+      response.data?.map((d) => new IkasState(d)),
+      response.graphQLErrors
+    );
+  }
+}

package/src/store/merchant/index.ts

@@ -0,0 +1,16 @@
+import { APIResponse } from "@ikas/fe-api-client";
+import {
+  listMerchantSettings,
+  ListMerchantSettingsQueryParams,
+} from "@ikas/storefront-api";
+import { IkasMerchantSettings } from "../../models/data";
+
+export default class MerchantStore {
+  static async listMerchantSettings(params: ListMerchantSettingsQueryParams) {
+    const response = await listMerchantSettings(params);
+    return new APIResponse(
+      response.data ? new IkasMerchantSettings(response.data) : null,
+      response.graphQLErrors
+    );
+  }
+}

package/src/store/product/index.ts

@@ -0,0 +1,113 @@
+import {
+  APIResponse,
+  getOrderLineFile,
+  GetOrderLineFileQueryParams,
+  getProductCampaigns,
+  GetProductCampaignsQueryParams,
+  getProductFilterData,
+  GetProductFilterDataQueryParams,
+  getRelatedProducts,
+  GetRelatedProductsQueryParams,
+  listProductAttribute,
+  ListProductAttributeQueryParams,
+  listProductBackInStockRemind,
+  ListProductBackInStockRemindQueryParams,
+  listProductOptionSet,
+  ListProductOptionSetQueryParams,
+  saveProductBackInStockRemind,
+  SaveProductBackInStockRemindQueryParams,
+  searchProducts,
+  SearchProductsQueryParams,
+} from "@ikas/storefront-api";
+import { IkasProduct } from "../../models/data/product";
+import { IkasProductAttribute } from "../../models/data/product/attribute";
+import { IkasProductCampaign } from "../../models/data/product/campaign";
+import { IkasProductFilter } from "../../models/data/product/filter";
+import { IkasProductOptionSet } from "../../models/data/product/option-set";
+import { IkasFilterCategory } from "../../models/data/filter-category";
+
+export default class ProductStore {
+  static async listProductBackInStockRemind(
+    params: ListProductBackInStockRemindQueryParams
+  ) {
+    return await listProductBackInStockRemind(params);
+  }
+
+  static async saveProductBackInStockRemind(
+    params: SaveProductBackInStockRemindQueryParams
+  ) {
+    return await saveProductBackInStockRemind(params);
+  }
+
+  static async searchProducts(params: SearchProductsQueryParams) {
+    const response = await searchProducts(params);
+    return new APIResponse({
+      ...response.data,
+      data: response.data?.data?.map((p) => new IkasProduct(p as IkasProduct)),
+    });
+  }
+
+  static async getProductFilterData(params: GetProductFilterDataQueryParams) {
+    const response = await getProductFilterData(params);
+    return new APIResponse(
+      response.data
+        ? {
+            filters: response.data.filters.map(
+              (f) => new IkasProductFilter(f as any)
+            ),
+            categories: response.data.categories?.map(
+              (c) => new IkasFilterCategory(c)
+            ),
+          }
+        : null,
+      response.graphQLErrors
+    );
+  }
+
+  static async getRelatedProducts(params: GetRelatedProductsQueryParams) {
+    const response = await getRelatedProducts(params);
+    return new APIResponse(
+      {
+        ...response.data,
+        data: response.data?.data?.map(
+          (p) => new IkasProduct(p as IkasProduct)
+        ),
+      },
+      response.graphQLErrors
+    );
+  }
+
+  static async listProductAttribute(params: ListProductAttributeQueryParams) {
+    const response = await listProductAttribute(params);
+    return new APIResponse(
+      response.data?.map(
+        (d) => new IkasProductAttribute(d as unknown as IkasProductAttribute)
+      ),
+      response.graphQLErrors
+    );
+  }
+
+  static async getProductCampaigns(params: GetProductCampaignsQueryParams) {
+    const response = await getProductCampaigns(params);
+    return new APIResponse(
+      response.data?.map(
+        (d) => new IkasProductCampaign(d as unknown as IkasProductCampaign)
+      ),
+      response.graphQLErrors
+    );
+  }
+
+  static async getOrderLineFile(params: GetOrderLineFileQueryParams) {
+    return await getOrderLineFile(params);
+  }
+
+  static async listProductOptionSet(params: ListProductOptionSetQueryParams) {
+    const response = await listProductOptionSet(params);
+    return new APIResponse(
+      response.data?.map(
+        (d) => new IkasProductOptionSet(d as unknown as IkasProductOptionSet)
+      ),
+      response.graphQLErrors
+    );
+  }
+}

package/src/store/raffle/index.ts

@@ -0,0 +1,58 @@
+import { APIResponse } from "@ikas/fe-api-client";
+import {
+  getRafflesByCustomerId,
+  GetRafflesByCustomerIdQueryParams,
+  listRaffle,
+  listRaffleMetaData,
+  ListRaffleMetadataQueryParams,
+  ListRaffleQueryParams,
+  saveRaffleParticipant,
+  SaveRaffleParticipantQueryParams,
+} from "@ikas/storefront-api";
+import {
+  IkasRaffle,
+  IkasRaffleParticipant,
+  IkasRaffleMetaData,
+} from "../../models/data/raffle";
+
+export default class RaffleStore {
+  static async listRaffle(params: ListRaffleQueryParams) {
+    const response = await listRaffle(params);
+    return new APIResponse({
+      ...response.data,
+      data: response.data?.data?.map(
+        (r) => new IkasRaffle(r as unknown as IkasRaffle)
+      ),
+    });
+  }
+
+  static async saveRaffleParticipant(params: SaveRaffleParticipantQueryParams) {
+    const response = await saveRaffleParticipant(params);
+    return new APIResponse(
+      response.data
+        ? new IkasRaffleParticipant(response.data as IkasRaffleParticipant)
+        : null,
+      response.graphQLErrors
+    );
+  }
+
+  static async listRaffleMetaData(params: ListRaffleMetadataQueryParams) {
+    const response = await listRaffleMetaData(params);
+    return new APIResponse(
+      response.data?.map(
+        (d) => new IkasRaffleMetaData(d as IkasRaffleMetaData)
+      ),
+      response.graphQLErrors
+    );
+  }
+
+  static async getRafflesByCustomerId(
+    params: GetRafflesByCustomerIdQueryParams
+  ) {
+    const response = await getRafflesByCustomerId(params);
+    return new APIResponse(
+      response.data?.map((d) => new IkasRaffle(d as unknown as IkasRaffle)),
+      response.graphQLErrors
+    );
+  }
+}

package/src/store/storefront/index.ts

@@ -0,0 +1,18 @@
+import {
+  APIResponse,
+  getStorefront,
+  GetStorefrontQueryParams,
+} from "@ikas/storefront-api";
+import { IkasStorefront } from "../../models/data";
+
+export default class StorefrontStore {
+  static async getStorefront(params: GetStorefrontQueryParams) {
+    const response = await getStorefront(params);
+    return new APIResponse(
+      response.data
+        ? new IkasStorefront(response.data as unknown as IkasStorefront)
+        : null,
+      response.graphQLErrors
+    );
+  }
+}

package/src/typings/global.d.ts

@@ -0,0 +1,7 @@
+declare module "*.scss" {
+  interface IClassNames {
+    [className: string]: string;
+  }
+  const classNames: IClassNames;
+  export = classNames;
+}

package/src/utils/constants.ts

@@ -0,0 +1,2 @@
+export const FREE_TEXT_CITY_COUNTRY_LIST = ["DE", "US"];
+export const DISTRICT_HIDDEN_COUNTRY_LIST = ["US"];

package/src/utils/currency.ts

@@ -0,0 +1,250 @@
+import { IkasStorefrontConfig } from "@ikas/storefront-config";
+
+const format = (p: number, n: number, x: number, s: string, c: string) => {
+  const re = "\\d(?=(\\d{" + (x || 3) + "})+" + (n > 0 ? "\\D" : "$") + ")",
+    num = p.toFixed(Math.max(0, ~~n));
+
+  return (c ? num.replace(".", c) : num).replace(
+    new RegExp(re, "g"),
+    "$&" + (s || ",")
+  );
+};
+
+/**
+ *
+ * @param price Price to format
+ * @param currencyCode Code for the currency, USD, EUR, TRY, etc..
+ */
+export const formatMoney = (price: number, currencyCode: string) => {
+  const formatSettings =
+    IkasStorefrontConfig.getMerchantSettings()?.currencyFormats?.find(
+      (s) => s.currencyCode === currencyCode
+    );
+  const symbol = formatSettings?.symbol || getCurrencySymbol(currencyCode);
+  const decimalSeparator = formatSettings?.decimalSeparator || ".";
+  const thousandSeparator = formatSettings?.thousandSeparator || ",";
+  const symbolPosition = formatSettings?.symbolPosition || "LEFT";
+  const decimalCount = 2;
+  const sectionLength = 3;
+
+  const omitZeroDecimal = (formattedNumber: string) => {
+    const parts = formattedNumber.split(decimalSeparator);
+    const decimalPart = parts[parts.length - 1];
+
+    if (decimalPart === "00") return parts[0];
+    else return formattedNumber;
+  };
+
+  const withSymbol = (formattedNumber: string) => {
+    if (symbolPosition === "LEFT") return `${symbol} ${formattedNumber}`;
+    else return `${formattedNumber} ${symbol}`;
+  };
+
+  try {
+    let formattedNumber = format(
+      price,
+      decimalCount,
+      sectionLength,
+      thousandSeparator,
+      decimalSeparator
+    );
+
+    if (formatSettings?.omitZeroDecimal) {
+      formattedNumber = omitZeroDecimal(formattedNumber);
+    }
+
+    return withSymbol(formattedNumber);
+  } catch (err) {
+    console.error(err);
+
+    // Fallback
+    const formatter = new Intl.NumberFormat(
+      IkasStorefrontConfig.getCurrentLocale(),
+      {
+        style: "currency",
+        currency: currencyCode || "TRY",
+      }
+    );
+
+    return formatter.format(price);
+  }
+};
+
+export function getCurrencySymbol(currencyCode: string) {
+  return CURRENCIES[currencyCode] || currencyCode;
+}
+
+const CURRENCIES: Record<string, string> = {
+  TRY: "₺",
+  USD: "$",
+  EUR: "€",
+  AZN: "₼",
+  AED: "د.إ.",
+  AFN: "؋",
+  ALL: "L",
+  AMD: "դր",
+  ANG: "ƒ",
+  AOA: "Kz",
+  ARS: "$",
+  AUD: "$",
+  AWG: "ƒ",
+  BAM: "КМ",
+  BBD: "$",
+  BDT: "৳",
+  BGN: "лв.",
+  BHD: "د.ب.",
+  BIF: "FBu",
+  BMD: "$",
+  BND: "$",
+  BOB: "Bs.",
+  BRL: "R$",
+  BSD: "$",
+  BTN: "Nu.",
+  BWP: "P",
+  BYN: "руб.",
+  BZD: "$",
+  CAD: "$",
+  CDF: "₣",
+  CHF: "₣",
+  CKD: "$",
+  CLP: "$",
+  CNY: "¥元",
+  COP: "$",
+  CRC: "₡",
+  CUC: "$",
+  CUP: "₱",
+  CVE: "$",
+  CZK: "Kč",
+  DJF: "ف.ج.",
+  DKK: "kr.",
+  DOP: "$",
+  DZD: "د.ج.",
+  EGP: "ج.م.",
+  EHP: "Ptas.",
+  ERN: "ناكفا",
+  ETB: "ብር",
+  FJD: "$",
+  FKP: "£",
+  FOK: "kr",
+  GBP: "£",
+  GEL: "₾",
+  GGP: "£",
+  GHS: "₵",
+  GIP: "£",
+  GMD: "D",
+  GNF: "FG",
+  GTQ: "$",
+  GYD: "$",
+  HKD: "$",
+  HNL: "L",
+  HRK: "kn",
+  HTG: "G",
+  HUF: "Ft",
+  IDR: "Rp",
+  ILS: "₪",
+  IMP: "£",
+  INR: "₹",
+  IQD: "د.ع.",
+  IRR: "﷼",
+  ISK: "kr",
+  JEP: "£",
+  JMD: "$",
+  JOD: "د.أ.",
+  JPY: "¥",
+  KES: "KSh",
+  KGS: "с",
+  KHR: "៛",
+  KID: "$",
+  KMF: "CF",
+  KPW: "₩",
+  KRW: "₩",
+  KWD: "د.ك.",
+  KYD: "$",
+  KZT: "₸",
+  LAK: "₭",
+  LBP: "ل.ل.",
+  LKR: "රු or ரூ",
+  LRD: "$",
+  LSL: "L",
+  LYD: "ل.د.",
+  MAD: "د.م.",
+  MDL: "L",
+  MGA: "Ar",
+  MKD: "ден",
+  MMK: "Ks",
+  MNT: "₮",
+  MOP: "MOP$",
+  MRU: "أ.م.",
+  MUR: "रु ",
+  MVR: ".ރ",
+  MWK: "MK",
+  MXN: "$",
+  MYR: "RM",
+  MZN: "MT",
+  NAD: "$",
+  NGN: "₦",
+  NIO: "C$",
+  NOK: "kr",
+  NPR: "रू",
+  NZD: "$",
+  OMR: "ر.ع.",
+  PAB: "B/.",
+  PEN: "S/.",
+  PGK: "K",
+  PHP: "₱",
+  PKR: "Rs",
+  PLN: "zł",
+  PND: "$",
+  PRB: "р.",
+  PYG: "₲",
+  QAR: "ر.ق.",
+  RON: "L",
+  RSD: "дин",
+  RUB: "₽",
+  RWF: "R₣",
+  SAR: "ر.س.",
+  SBD: "$",
+  SCR: "Rs",
+  SDG: "ج.س.",
+  SEK: "kr",
+  SGD: "$",
+  SHP: "£",
+  SLL: "Le",
+  SLS: "Sl",
+  SOS: "Ssh",
+  SRD: "$",
+  SSP: "SS£",
+  STN: "Db",
+  SVC: "₡",
+  SYP: "ل.س.",
+  SZL: "L",
+  THB: "฿",
+  TJS: "SM",
+  TMT: "T",
+  TND: "د.ت.",
+  TOP: "PT",
+  TTD: "$",
+  TVD: "$",
+  TWD: "圓",
+  TZS: "TSh",
+  UAH: "грн",
+  UGX: "Sh",
+  UYU: "$",
+  UZS: "сум",
+  VED: "Bs.",
+  VES: "Bs.F",
+  VND: "₫",
+  VUV: "VT",
+  WST: "ST",
+  XAF: "Fr.",
+  XCD: "$",
+  XOF: "₣",
+  XPF: "₣",
+  YER: "ر.ي.",
+  ZAR: "R",
+  ZMW: "ZK",
+  ZWB: "",
+  ZWL: "$",
+  Abkhazia: "",
+  Artsakh: "դր.",
+};

package/src/utils/google-fonts.ts

@@ -0,0 +1,52 @@
+import { IkasThemeJsonFontFamily } from "@ikas/storefront-models";
+
+export const getGoogleFontHref = (fontFamily: IkasThemeJsonFontFamily) => {
+  if (!fontFamily.name) return;
+
+  const fontName = fontFamily.name.replace(/ /g, "+");
+  let fontVariants = "";
+
+  if (fontFamily.variants) {
+    fontVariants += ":";
+    const isItalic = fontFamily.variants.some(
+      (variant) => variant === "italic"
+    );
+    if (isItalic) {
+      fontVariants += "ital,";
+    }
+
+    fontVariants += "wght@";
+
+    if (isItalic) {
+      const search = "italic";
+      const checkItalic = new RegExp(search, "i");
+      fontVariants += fontFamily.variants.reduce((str, variant) => {
+        if (!checkItalic.test(variant)) {
+          return str + `0,${variant.replace("regular", "400")};`;
+        } else {
+          return str;
+        }
+      }, "");
+
+      fontVariants += fontFamily.variants.reduce((str, variant) => {
+        if (checkItalic.test(variant)) {
+          return (
+            str +
+            `1,${variant === "italic" ? "400" : variant.replace("italic", "")};`
+          );
+        } else {
+          return str;
+        }
+      }, "");
+    } else {
+      fontVariants += fontFamily.variants.reduce((str, variant) => {
+        return str + `${variant.replace("regular", "400")};`;
+      }, "");
+    }
+
+    fontVariants = fontVariants.substring(0, fontVariants.length - 1);
+    fontVariants += "&display=swap";
+  }
+
+  return `https://fonts.googleapis.com/css2?family=${fontName}${fontVariants}`;
+};

package/src/utils/helper.ts

@@ -0,0 +1,77 @@
+import { IkasStorefrontConfig } from "@ikas/storefront-config";
+
+export function findAllIndexes(str: string, pattern: string) {
+  const indexes: number[] = [];
+  if (!str || !pattern) return [];
+
+  let index = 0;
+  while (index < str.length) {
+    const patternIndex = str.indexOf(pattern, index);
+
+    if (patternIndex === -1) break;
+    index = patternIndex + 1;
+    indexes.push(patternIndex);
+  }
+
+  return indexes;
+}
+
+export function stringSorter(atitle: string, btitle: string): number {
+  const alphabet =
+    "0123456789AaBbCcÇçDdEeFfGgĞğHhIıİiJjKkLlMmNnOoÖöPpQqRrSsŞşTtUuÜüVvWwXxYyZz";
+
+  const _atitle = atitle || "";
+  const _btitle = btitle || "";
+
+  if (_atitle.length === 0 || _btitle.length === 0) {
+    return _atitle.length - _btitle.length;
+  }
+  for (let i = 0; i < _atitle.length && i < _btitle.length; i++) {
+    const ai = alphabet.indexOf(_atitle[i].toUpperCase());
+    const bi = alphabet.indexOf(_btitle[i].toUpperCase());
+    if (ai !== bi) {
+      return ai - bi;
+    }
+  }
+  return 0;
+}
+
+function is12Hour(locale: string) {
+  return !!new Intl.DateTimeFormat(locale, { hour: "numeric" })
+    .format(0)
+    .match(/\s/);
+}
+
+export function tryForEach(
+  items: Array<any>,
+  callback: (item: any, index: number) => void,
+  printErrors = false
+) {
+  items.forEach((value, index) => {
+    try {
+      callback(value, index);
+    } catch (err) {
+      if (printErrors) console.error(err);
+    }
+  });
+}
+
+export function formatDate(date: Date) {
+  const options: Intl.DateTimeFormatOptions = {
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+    hour: "numeric",
+    minute: "numeric",
+    hour12: false,
+  };
+  const locale = IkasStorefrontConfig.getCurrentLocale();
+
+  if (typeof navigator !== "undefined") {
+    options.hour12 = is12Hour(navigator.language);
+  } else {
+    options.hour12 = is12Hour(locale);
+  }
+
+  return new Intl.DateTimeFormat(locale, options).format(date);
+}