@ikas/storefront 1.0.21 → 2.0.0-alpha.1

package/src/utils/currency.ts

@@ -0,0 +1,229 @@
+import { IkasStorefrontConfig } from "../storefront";
+
+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 currency Code for the currency, USD, EUR, TRY, etc..
+ */
+
+export const formatMoney = (price: number, currency: string) => {
+  try {
+    const symbol = getCurrencySymbol(currency);
+    const decimalSeperator = ".";
+    const sectionSeperator = ",";
+    const decimalLength = 2;
+    const sectionLength = 3;
+
+    const formattedNumber = format(
+      price,
+      decimalLength,
+      sectionLength,
+      sectionSeperator,
+      decimalSeperator
+    );
+
+    return symbol + " " + formattedNumber;
+  } catch (err) {
+    console.error(err);
+
+    // Fallback
+    const formatter = new Intl.NumberFormat(
+      IkasStorefrontConfig.getCurrentLocale(),
+      {
+        style: "currency",
+        currency: currency || "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/fs.ts

@@ -0,0 +1,84 @@
+import fs from "fs-extra";
+import path from "path";
+
+/**
+ * Divides the given filePath string into directory part and fileName part
+ * @param path Path for the file
+ */
+export function getFilePathParts(path: string) {
+  const componentFilePathParts = path.split("/");
+
+  if (componentFilePathParts.length > 1) {
+    const dirParts = componentFilePathParts.slice(
+      0,
+      componentFilePathParts.length - 1
+    );
+    const filePart = componentFilePathParts[componentFilePathParts.length - 1];
+
+    return {
+      dirParts,
+      filePart,
+    };
+  }
+
+  return {
+    filePart: path,
+  };
+}
+
+/**
+ * Deletes the contents of the given directory, exluding the ignoreFiles
+ * @param dirPath Path for the directory
+ * @param ignoreFiles List of files to keep in directory. Does not accept recursive paths, only first level files
+ *
+ * @returns true for successfull operation, false otherwise
+ */
+export function deleteDirContent(dirPath: string, ignoreFiles?: string[]) {
+  try {
+    const files = fs.readdirSync(dirPath);
+
+    files.forEach((file) => {
+      if (!ignoreFiles?.includes(file)) {
+        fs.removeSync(path.join(dirPath, file));
+      }
+    });
+
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+/**
+ * Creates the given file and directories for the filePath
+ * @param basePath Base directory path for the file
+ * @param fileSubPath Filename or the sub directory path for the file to write
+ * @param fileStr File contents
+ *
+ * @returns true for successfull operation, false otherwise
+ */
+export function createFile(
+  basePath: string,
+  fileSubPath: string,
+  fileStr: string
+) {
+  try {
+    let generatedFolderPath = basePath;
+
+    const pageFilePathParts = getFilePathParts(fileSubPath);
+    if (pageFilePathParts.dirParts?.length) {
+      generatedFolderPath = path.join(
+        generatedFolderPath,
+        ...pageFilePathParts.dirParts
+      );
+    }
+
+    const filePath = path.join(generatedFolderPath, pageFilePathParts.filePart);
+    fs.outputFileSync(filePath, fileStr);
+
+    return true;
+  } catch (err) {
+    console.error(err);
+    return false;
+  }
+}

package/src/utils/helper.ts

@@ -0,0 +1,133 @@
+import { IkasStorefrontConfig } from "../storefront";
+import _forEach from "lodash/forEach";
+
+export const stringToSlug = (str: string) => {
+  str = str.replace(/^\s+|\s+$/g, ""); // trim
+  str = str.toLocaleLowerCase("tr-TR");
+
+  // remove accents, swap ñ for n, etc
+  const from = "àáäâèéëêìíïîıòóöôùúüûñçşğ·/_,:;";
+  const to = "aaaaeeeeiiiiioooouuuuncsg------";
+  for (let i = 0, l = from.length; i < l; i++) {
+    str = str.replace(new RegExp(from.charAt(i), "g"), to.charAt(i));
+  }
+
+  str = str
+    .replace(/[^a-z0-9 -]/g, "") // remove invalid chars
+    .replace(/\s+/g, "-") // collapse whitespace and replace by -
+    .replace(/-+/g, "-"); // collapse dashes
+
+  return str;
+};
+
+export const validatePhoneNumber = (str: string) => {
+  const regex = /^\+?\d+$/;
+  return regex.test(str);
+};
+
+export const pascalCase = (str: string) => {
+  const lower = str.toLocaleLowerCase("tr-TR");
+  return lower.charAt(0).toLocaleUpperCase("tr-TR") + lower.slice(1);
+};
+
+export const decodeBase64 = (base64: string) => {
+  const buffer = Buffer.from(base64, "base64");
+  return buffer.toString("ascii");
+};
+
+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;
+}
+
+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;
+}
+
+function is12Hour(locale: string) {
+  return !!new Intl.DateTimeFormat(locale, { hour: "numeric" })
+    .format(0)
+    .match(/\s/);
+}
+
+export function formatDate(date: Date) {
+  const options: any = {
+    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);
+}
+
+export function tryForEach(
+  items: Array<any>,
+  callback: (item: any, index: number) => void,
+  printErrors = false
+) {
+  _forEach(items, (value, index) => {
+    try {
+      callback(value, index);
+    } catch (err) {
+      if (printErrors) console.error(err);
+    }
+  });
+}
+
+export function findAllByKey(obj: Record<string, any>, keyToFind: string): any {
+  return Object.entries(obj || {}).reduce(
+    (acc, [key, value]) =>
+      key === keyToFind
+        ? acc.concat(value)
+        : typeof value === "object"
+        ? acc.concat(findAllByKey(value, keyToFind))
+        : acc,
+    []
+  );
+}
+
+export function sortObject(obj: Record<string, any>) {
+  return Object.keys(obj)
+    .sort()
+    .reduce((sortedObj: Record<string, any>, key) => {
+      sortedObj[key] = obj[key];
+      return sortedObj;
+    }, {});
+}

package/src/utils/i18n.ts

@@ -0,0 +1,204 @@
+import fs from "fs";
+import path from "path";
+import _get from "lodash/get";
+import { IkasStorefrontConfig } from "../storefront";
+import { findAllIndexes } from "./helper";
+
+export const CHECKOUT_TRANSLATION_NAMESPACE = "checkout-page";
+export type TFunction = (
+  pathString: string,
+  params?: Record<string, any>
+) => string;
+
+export class I18NFileReader {
+  locale: string;
+  namespaces: string[];
+  localePath?: string;
+
+  constructor(locale: string, namespaces: string[], localePath?: string) {
+    this.locale = locale;
+    this.namespaces = namespaces;
+    this.localePath = localePath;
+  }
+
+  async read(): Promise<Record<string, any>> {
+    const translations: Record<string, any> = {};
+
+    for (const namespace of this.namespaces) {
+      try {
+        const filePath = this.localePath
+          ? path.join(this.localePath, this.locale, namespace + ".json")
+          : path.join(
+              process.cwd(),
+              "public",
+              "locales",
+              this.locale,
+              namespace + ".json"
+            );
+        const fileExists = fs.existsSync(filePath);
+
+        if (fileExists) {
+          const localeTranslation = await this.readLocaleFile(filePath);
+          translations[namespace] = localeTranslation;
+        } else if (namespace === CHECKOUT_TRANSLATION_NAMESPACE) {
+          let checkoutTranslation: Record<string, any> = {};
+
+          if (this.locale === "tr") {
+            const imported = await import(
+              //@ts-ignore
+              "../assets/translations/checkout/tr.js"
+            );
+            checkoutTranslation = imported.default;
+          } else {
+            const imported = await import(
+              //@ts-ignore
+              "../assets/translations/checkout/en.js"
+            );
+            checkoutTranslation = imported.default;
+          }
+
+          translations[namespace] = checkoutTranslation;
+        }
+      } catch (err) {
+        console.error(err);
+      }
+    }
+
+    return translations;
+  }
+
+  private async readLocaleFile(filePath: string): Promise<Record<string, any>> {
+    return new Promise((resolve, reject) => {
+      fs.readFile(
+        filePath,
+        {
+          flag: "r",
+        },
+        function (err, file) {
+          if (err) {
+            return reject(err);
+          }
+          const result = file.length ? JSON.parse(file.toString()) : {};
+          resolve(result);
+        }
+      );
+    });
+  }
+}
+
+function t(pathString: string, params?: Record<string, any>): string {
+  let namespace = "common";
+  let path = "";
+  const parts = pathString.split(":");
+
+  if (parts.length > 2) {
+    return pathString;
+  } else if (parts.length === 2) {
+    namespace = parts[0];
+    path = parts[1];
+  } else {
+    path = parts[0];
+  }
+
+  const namespaceTranslations = IkasStorefrontConfig.translations[namespace];
+  if (!namespaceTranslations) return pathString;
+
+  const str = _get(namespaceTranslations, path);
+  if (str) {
+    if (params) {
+      const allInputData = createTranslationInputData(str);
+      let newStr = "";
+
+      for (const inputData of allInputData) {
+        if (inputData.isVariable) {
+          const variableName = inputData.value
+            .replace("{{", "")
+            .replace("}}", "")
+            .trim();
+
+          if (params[variableName]) {
+            newStr += params[variableName];
+          } else {
+            newStr += inputData.value;
+          }
+        } else {
+          newStr += inputData.value;
+        }
+      }
+
+      return newStr;
+    } else return str;
+  }
+
+  return pathString;
+}
+
+export function useTranslation(namespace?: string | string[]) {
+  return {
+    t,
+  };
+}
+
+export function createTranslationInputData(value: string) {
+  const currentData: InputData[] = [];
+  if (!value) return currentData;
+
+  const variableStartIndexes = findAllIndexes(value, "{{");
+  const variableEndIndexes = findAllIndexes(value, "}}");
+
+  const variableIndexPairs = variableStartIndexes.map((startIndex, index) => {
+    const endIndex = variableEndIndexes[index] + 1;
+    return {
+      start: startIndex,
+      end: endIndex,
+    };
+  });
+
+  const isVariableIndex = (index: number) =>
+    variableIndexPairs.some((pair) => pair.start <= index && pair.end >= index);
+
+  let currentValue = "";
+  let isVariable = false;
+
+  for (let i = 0; i < value.length; i++) {
+    const currentChar = value.charAt(i);
+
+    if (isVariable) {
+      if (isVariableIndex(i)) {
+        currentValue += currentChar;
+      } else {
+        currentData.push({
+          isVariable: true,
+          value: currentValue,
+        });
+        currentValue = currentChar;
+        isVariable = false;
+      }
+    } else {
+      if (isVariableIndex(i)) {
+        currentData.push({
+          isVariable: false,
+          value: currentValue,
+        });
+        currentValue = currentChar;
+        isVariable = true;
+      } else {
+        currentValue += currentChar;
+      }
+    }
+
+    if (i === value.length - 1) {
+      currentData.push({
+        isVariable,
+        value: currentValue,
+      });
+    }
+  }
+
+  return currentData;
+}
+
+type InputData = {
+  value: string;
+  isVariable: boolean;
+};

package/{build/utils/index.d.ts → src/utils/index.ts}

@@ -1,3 +1,3 @@
-export * from "./helper";
-export * from "./currency";
-export { useTranslation, createTranslationInputData } from "./i18n";
+export * from "./helper";
+export * from "./currency";
+export { useTranslation, createTranslationInputData } from "./i18n";