@cuemath/web-utils 1.0.1 → 1.0.2

package/src/local-storage/index.ts

@@ -0,0 +1,196 @@
+import { TWENTY_FOUR_HOURS_IN_SECONDS } from '../constants/date-time';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export const LOCAL_STORAGE_PRIMARY_KEY = 'CUEMATH_WEB';
+
+export const checkLocalStorageSupport = (): boolean => {
+  try {
+    return 'localStorage' in window && window.localStorage !== null;
+  } catch (e) {
+    return false;
+  }
+};
+
+export const removeKeyFromObject = (
+  obj: { [x: string]: any },
+  keyToRemove: string,
+): null | { [x: string]: any } => {
+  if (obj) {
+    delete obj[keyToRemove];
+
+    return obj;
+  }
+
+  return null;
+};
+
+// Default expiry set to 24 hours
+export const localStorageSet = (
+  key: string | number,
+  value: any,
+  ttl = TWENTY_FOUR_HOURS_IN_SECONDS,
+): boolean => {
+  if (checkLocalStorageSupport()) {
+    try {
+      let dbData: any = window.localStorage.getItem(LOCAL_STORAGE_PRIMARY_KEY);
+      const now = new Date();
+
+      const item = {
+        value,
+        expiry: now.getTime() + ttl,
+      };
+
+      if (dbData) {
+        dbData = JSON.parse(dbData);
+        dbData[key] = item;
+      } else {
+        dbData = { [key]: item };
+      }
+
+      window.localStorage.setItem(LOCAL_STORAGE_PRIMARY_KEY, JSON.stringify(dbData));
+
+      return true;
+    } catch (e) {
+      return false;
+    } // case when localStorage space quota is exceeded
+  } else {
+    return false;
+  }
+};
+
+export const localStorageGet = (key: string): null | string => {
+  if (checkLocalStorageSupport()) {
+    try {
+      const primaryLocalStorageValue = window.localStorage.getItem(
+        LOCAL_STORAGE_PRIMARY_KEY,
+      );
+      let dbData =
+        primaryLocalStorageValue != null
+          ? JSON.parse(primaryLocalStorageValue)
+          : primaryLocalStorageValue;
+      const requestedData = dbData[key];
+      const now = new Date();
+
+      if (now.getTime() > requestedData.expiry) {
+        dbData = removeKeyFromObject(dbData, key);
+        window.localStorage.setItem(LOCAL_STORAGE_PRIMARY_KEY, JSON.stringify(dbData));
+
+        return null;
+      }
+
+      return requestedData.value;
+    } catch (e) {
+      return null;
+    }
+  } else {
+    return null;
+  }
+};
+
+export const localStorageGetAll = (): null | string => {
+  if (checkLocalStorageSupport()) {
+    try {
+      const primaryLocalStorageValue = window.localStorage.getItem(
+        LOCAL_STORAGE_PRIMARY_KEY,
+      );
+
+      return primaryLocalStorageValue != null
+        ? JSON.parse(primaryLocalStorageValue)
+        : primaryLocalStorageValue;
+    } catch (e) {
+      return null;
+    }
+  } else {
+    return null;
+  }
+};
+
+export const localStorageRemove = (key: string): boolean => {
+  if (checkLocalStorageSupport()) {
+    try {
+      const primaryLocalStorageValue = window.localStorage.getItem(
+        LOCAL_STORAGE_PRIMARY_KEY,
+      );
+      let dbData =
+        primaryLocalStorageValue != null
+          ? JSON.parse(primaryLocalStorageValue)
+          : primaryLocalStorageValue;
+
+      if (dbData[key]) {
+        dbData = removeKeyFromObject(dbData, key);
+        window.localStorage.setItem(LOCAL_STORAGE_PRIMARY_KEY, JSON.stringify(dbData));
+
+        return true;
+      }
+
+      return false;
+    } catch (e) {
+      return false;
+    }
+  } else {
+    return false;
+  }
+};
+
+export const localStorageRemoveAll = (): boolean => {
+  if (checkLocalStorageSupport()) {
+    try {
+      const primaryLocalStorageValue = window.localStorage.getItem(
+        LOCAL_STORAGE_PRIMARY_KEY,
+      );
+      const dbData =
+        primaryLocalStorageValue != null
+          ? JSON.parse(primaryLocalStorageValue)
+          : primaryLocalStorageValue;
+
+      if (dbData) {
+        window.localStorage.removeItem(LOCAL_STORAGE_PRIMARY_KEY);
+
+        return true;
+      }
+
+      return false;
+    } catch (e) {
+      return false;
+    }
+  } else {
+    return false;
+  }
+};
+
+export const removeExpiredKeysOnMount = (): boolean => {
+  if (checkLocalStorageSupport()) {
+    try {
+      const primaryLocalStorageValue = window.localStorage.getItem(
+        LOCAL_STORAGE_PRIMARY_KEY,
+      );
+      let dbData =
+        primaryLocalStorageValue != null
+          ? JSON.parse(primaryLocalStorageValue)
+          : primaryLocalStorageValue;
+      const now = new Date();
+
+      if (dbData) {
+        dbData = Object.keys(dbData).reduce((accumulator: any, key) => {
+          if (now.getTime() < dbData[key].expiry) {
+            accumulator[key] = dbData[key];
+          }
+
+          return accumulator;
+        }, {});
+      }
+
+      if (Object.keys(dbData).length) {
+        window.localStorage.setItem(LOCAL_STORAGE_PRIMARY_KEY, JSON.stringify(dbData));
+      } else {
+        localStorageRemoveAll();
+      }
+
+      return true;
+    } catch (e) {
+      return false;
+    }
+  } else {
+    return false;
+  }
+};

package/src/object/index.ts

@@ -0,0 +1,43 @@
+export function isEmpty(obj: object): boolean {
+  return Object.keys(obj).length === 0;
+}
+
+// In this case both object have same key names Don't use to compare objects
+export function isMapEqual(
+  map1: { [x: string]: any },
+  map2: { [x: string]: any },
+): boolean {
+  const map1Keys = Object.keys(map1);
+  const map2Keys = Object.keys(map2);
+
+  if (map1Keys.length !== map2Keys.length) {
+    return false;
+  }
+  for (let i = 0; i < map1Keys.length; i += 1) {
+    const key = map1Keys[i];
+
+    if (map1[key] !== map2[key]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+export function nestedMapsAreEqual(map1: Map<any, any>, map2: Map<any, any>): boolean {
+  // First, check if the maps have the same size
+  if (map1.size !== map2.size) {
+    return false;
+  }
+
+  // Then, iterate over each key-value pair in map1 and check if the corresponding key-value pair exists in map2
+  for (const [key, value] of map1) {
+    if (!map2.has(key) || map2.get(key) !== value) {
+      // If the key doesn't exist in map2, or the value for the key is different, the maps are not equal
+      return false;
+    }
+  }
+
+  // If we haven't returned false by now, the maps are equal
+  return true;
+}