@ikas/storefront-next 4.0.0-alpha.10

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/i18n.ts

@@ -0,0 +1,80 @@
+import fs from "fs";
+import path from "path";
+
+export const CHECKOUT_TRANSLATION_NAMESPACE = "checkout-page";
+
+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
+              "@ikas/storefront-assets/checkout/tr.js"
+            );
+            checkoutTranslation = imported.default;
+          } else {
+            const imported = await import(
+              //@ts-ignore
+              "@ikas/storefront-assets/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);
+        }
+      );
+    });
+  }
+}