l-min-components 1.7.1314 → 1.7.1315

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "l-min-components",
-  "version": "1.7.1314",
+  "version": "1.7.1315",
   "type": "module",
   "files": [
     "src/assets",
     "src/components",
-    "src/hooks"
+    "src/hooks",
+    "src/utils"
   ],
   "scripts": {
     "dev": "vite",

package/src/utils/authRoutes.js

@@ -0,0 +1,3 @@
+const authRoutes = ["/"];
+
+export default authRoutes;

package/src/utils/axiosConfig.js

@@ -0,0 +1,131 @@
+import Axios from "axios";
+import { toast } from "react-toastify";
+
+const pendingRequests = new Map();
+
+const axios = Axios.create({
+  baseURL:
+    window.location.hostname.includes("staging") ||
+    window.location.hostname.includes("localhost")
+      ? "https://dev-117782726-api.learngual.com"
+      : "https://api.learngual.com",
+});
+
+axios.interceptors.request.use(
+  async (config) => {
+    // preventing duplicate requests >> starts
+    const requestKey = config.url;
+
+    if (pendingRequests.has(requestKey)) {
+      console.log("preventing::", requestKey);
+      return Promise.reject(new Axios.Cancel("Duplicate request"));
+    }
+
+    const source = Axios.CancelToken.source();
+    pendingRequests.set(requestKey, source);
+    config.cancelToken = source.token;
+    // preventing duplicate requests ends >>
+
+    const cookies = document.cookie;
+    const cookieArray = cookies.split(";");
+
+    let token;
+    let defaultAccountID;
+
+    for (let i = 0; i < cookieArray.length; i++) {
+      const cookie = cookieArray[i].trim();
+
+      if (cookie.startsWith("access=")) {
+        token = cookie.substring("access=".length, cookie.length);
+        break;
+      }
+    }
+
+    for (let i = 0; i < cookieArray.length; i++) {
+      const cookie = cookieArray[i].trim();
+      if (cookie.startsWith("defaultAccountID=")) {
+        defaultAccountID = cookie.substring(
+          "defaultAccountID=".length,
+          cookie.length
+        );
+        break;
+      }
+    }
+
+    // Add additional logic to check if the current request path matches any authRoutes
+    // const currentPath = config.url;
+    // const matchedRoute = authRoutes.find((route) =>
+    //   currentPath.includes(route)
+    // );
+    if (token) {
+      config.headers.Authorization = `Bearer ${token}`;
+      const date = new Date();
+      const params = {
+        // ...config.params,
+        // // _tz: date.getTimezoneOffset() / 60,
+        // _account: defaultAccountID,
+        // //
+
+        _account: defaultAccountID,
+        ...config.params,
+      };
+      config.params = params;
+    }
+
+    return config;
+  },
+  (error) => {
+    return Promise.reject(error);
+  }
+);
+
+// axios.interceptors.response.use(
+//   function (response) {
+//     // Any status code that lie within the range of 2xx cause this function to trigger
+//     // Do something with response data
+//     if (response.status === 403) {
+//       // Handle unauthorized access
+//       toast.error("Unauthorized");
+//       //console.log(response.status, "+++++++REPONSE ====");
+//     }
+//     return response;
+//   },
+//   function (error) {
+//     // Any status codes that fall outside the range of 2xx cause this function to trigger
+//     // Do something with response error
+//     return Promise.reject(error);
+//   }
+// );
+
+axios.interceptors.response.use(
+  (response) => {
+    pendingRequests.delete(response.config.url);
+    console.log("deleting", response.config.url);
+    if (
+      response.status === 207 &&
+      !window.location.host.includes("staging") &&
+      !window.location.host.includes("local")
+    ) {
+      window.location.href = "/auth/account-type";
+    }
+    return response;
+  },
+  (err) => {
+    if (err) {
+      if (err.config) pendingRequests.delete(err.config.url);
+
+      // If it's not a cancellation error, handle it as usual
+      if (!Axios.isCancel(err)) {
+        if (err.response?.status === 403) {
+          toast.error(err?.response.data?.detail);
+        }
+        return err;
+      } else {
+        return {};
+      }
+      // return err;
+    }
+  }
+);
+
+export default axios;

package/src/utils/db.js

@@ -0,0 +1,13 @@
+import Dexie from "dexie";
+import locale from "iso-639-1";
+export const db = new Dexie("translations");
+
+const languages = locale.getAllCodes();
+db.version(2).stores({
+  kwarg: "&key, value, screenId",
+  ...languages.reduce(
+    (x, y) => ({ ...x, [y]: "&key, value, screenId, updatedAt" }),
+    {}
+  ),
+  words: "&text, screenId, updatedAt",
+});

package/src/utils/deleteCookies.js

@@ -0,0 +1,59 @@
+import Cookies from "js-cookie";
+
+/**
+ * Delete a single cookie for specific domain and path configuration
+ * @param {string} name - Cookie name to delete
+ * @param {Object} options - Cookie options (domain, expires, path)
+ */
+const deleteSingleCookie = (name, options) => {
+  Cookies.remove(name, options);
+};
+
+/**
+ * Delete cookies on domain and all subdomains
+ * @param {string|string[]} names - Cookie name or array of cookie names to delete
+ */
+const deleteCookies = (names) => {
+  // Convert single name to array for consistent handling
+  const cookieNames = Array.isArray(names) ? names : [names];
+  
+  const date = new Date();
+  date.setHours(date.getHours() - 1);
+  const { host } = window.location;
+  const env = host.includes("localhost")
+    ? "local"
+    : host.includes("test") || host.includes("staging")
+    ? "staging"
+    : "production";
+
+  // Process each cookie name
+  cookieNames.forEach(name => {
+    if (env === "local") {
+      // For local environment
+      const localDomains = [".localhost", "localhost"];
+      localDomains.forEach(domain => {
+        deleteSingleCookie(name, {
+          domain,
+          expires: date,
+          path: "/",
+        });
+      });
+      // Also delete without domain specification for local testing
+      deleteSingleCookie(name, {
+        expires: date,
+        path: "/",
+      });
+    } else {
+      // For staging and production environments
+      const domain = ".learngual.com";
+      // Delete for main domain and all potential subdomains
+      deleteSingleCookie(name, {
+        domain,
+        expires: date,
+        path: "/",
+      });
+    }
+  });
+};
+
+export default deleteCookies;

package/src/utils/test/translation.test.js

@@ -0,0 +1,2 @@
+const sheetUrl =
+  "https://docs.google.com/spreadsheets/d/1VoV2Etjg9Ft4bhML_7IAfNRQ9AxmpU-JvKgal0QGhdI/edit?usp=sharing";

package/src/utils/translation.js

@@ -0,0 +1,68 @@
+import { db } from "./db";
+import axios from "./axiosConfig";
+
+async function loadTranslations(language = "ko") {
+  await new Promise((resolve) => {
+    //check if loading else resolve
+    if (document.readyState === "complete") {
+      return resolve();
+    }
+    window.addEventListener("load", resolve);
+  });
+
+  const screenId = btoa(window.location.href);
+
+  /**
+   * @typedef {{text: string; screenId: string; updatedAt: string}} WORDS
+   * @type {WORDS[]}
+   */
+  const words = await db.words.where({ screenId }).toArray();
+  const texts = words.map((x) => x.text); // list of texts
+
+  /**
+   * @typedef {{ key: string; value: string; screenId: string }} Kwarg
+   * @type {Kwarg[]} kwargList
+   */
+  const kwargList = await db.kwarg.where({ screenId }).toArray();
+  const kwargs = kwargList.reduce((x, t) => ({ ...x, [t.key]: t.value }), {});
+  /**
+   * @type {{ data: {has_translated: boolean; result: string[]} }}
+   */
+  const res = await axios({
+    url: "/iam/v1/utils/translate/",
+    method: "POST",
+    data: {
+      language,
+      sentences: texts,
+      kwargs,
+    },
+    params: {
+      _account: "",
+    },
+    authRequired: false,
+  });
+  // build an object using texts as key and results from request as value
+  if (!res.data) return {}; // somehow data was not found
+  const translations = texts.reduce(
+    (x, y, z) => ({ ...x, [y]: res.data.result[z] }),
+    {}
+  );
+  db[language].bulkPut(
+    Object.keys(translations).map((x, i) => ({
+      key: texts[i],
+      value: translations[x],
+      screenId,
+      updatedAt: new Date().toDateString(),
+    }))
+  );
+
+  return translations;
+}
+
+export function extractBracedText(text) {
+  const pattern = /\{([^}]+)\}/g; // Match all occurrences of text within {}
+  const matches = text.match(pattern);
+  return matches ? matches.map((match) => match.slice(1, -1)) : []; // Remove braces
+}
+
+export default loadTranslations;

package/src/utils/webm2wav.js

@@ -0,0 +1,81 @@
+function writeString(view, offset, string) {
+  for (let i = 0; i < string.length; i++) {
+    view.setUint8(offset + i, string.charCodeAt(i));
+  }
+}
+
+function audioBufferToWav(audioBuffer) {
+  const numChannels = audioBuffer.numberOfChannels;
+  const sampleRate = audioBuffer.sampleRate;
+  const format = 1;
+  const bitDepth = 16;
+
+  const bytesPerSample = bitDepth / 8;
+  const blockAlign = numChannels * bytesPerSample;
+  const byteRate = sampleRate * blockAlign;
+
+  const pcmChannels = [];
+  for (let i = 0; i < numChannels; i++) {
+    pcmChannels.push(audioBuffer.getChannelData(i));
+  }
+
+  const pcmDataLength = pcmChannels[0].length;
+  const dataSize = pcmDataLength * numChannels * bytesPerSample;
+
+  const interleavedPcm = new Int16Array(pcmDataLength * numChannels);
+  let outputOffset = 0;
+  for (let i = 0; i < pcmDataLength; i++) {
+    for (let channel = 0; channel < numChannels; channel++) {
+      let sample = pcmChannels[channel][i];
+      sample = Math.max(-1, Math.min(1, sample));
+      interleavedPcm[outputOffset++] =
+        sample < 0 ? sample * 0x8000 : sample * 0x7fff;
+    }
+  }
+
+  const buffer = new ArrayBuffer(44 + dataSize);
+  const view = new DataView(buffer);
+
+  writeString(view, 0, "RIFF");
+  view.setUint32(4, 36 + dataSize, true);
+  writeString(view, 8, "WAVE");
+
+  writeString(view, 12, "fmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, format, true);
+  view.setUint16(22, numChannels, true);
+  view.setUint32(24, sampleRate, true);
+  view.setUint32(28, byteRate, true);
+  view.setUint16(32, blockAlign, true);
+  view.setUint16(34, bitDepth, true);
+
+  writeString(view, 36, "data");
+  view.setUint32(40, dataSize, true);
+
+  new Int16Array(buffer, 44).set(interleavedPcm);
+
+  return new Blob([view], { type: "audio/wav" });
+}
+
+export default async function convertBlobToWav(blob) {
+  if (!blob || blob.size === 0) {
+    throw new Error("Input blob is empty or null. Cannot convert to WAV.");
+  }
+
+  let audioContext;
+  try {
+    audioContext = new (window.AudioContext || window.webkitAudioContext)();
+    const arrayBuffer = await blob.arrayBuffer();
+    const audioBuffer = await audioContext.decodeAudioData(arrayBuffer);
+    const wavBlob = audioBufferToWav(audioBuffer);
+
+    return wavBlob;
+  } catch (error) {
+    console.error("Error during blob to WAV conversion:", error);
+    throw new Error(`Failed to convert blob to WAV: ${error.message}`);
+  } finally {
+    if (audioContext && audioContext.state !== "closed") {
+      await audioContext.close();
+    }
+  }
+}