@cuemath/web-utils 1.0.0 → 1.0.2

package/src/date-time-helper/index.ts

@@ -0,0 +1,139 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import dayjs from 'dayjs';
+import relativeTime from 'dayjs/plugin/relativeTime';
+
+import { timezones } from '../constants/date-time/international-timezones';
+
+type Timestamp = number;
+
+export interface DateSlots {
+  key: number;
+  label: string;
+  subLabel: string;
+  disabled: boolean;
+}
+
+export const formatDateTime = (
+  dateTime: string | number | Date | dayjs.Dayjs | null | undefined,
+  format: string | undefined,
+) => {
+  const momentDate = dayjs(dateTime);
+
+  return momentDate.format(format);
+};
+
+export function getCurrentTimestamp(): number {
+  if (!Date.now) {
+    Date.now = () => new Date().getTime();
+  }
+
+  return Math.floor(Date.now() / 1000);
+}
+
+export function dateTimeByTimezone(timestamp: Timestamp, timezone?: string): string {
+  let options = {};
+
+  if (timezone) {
+    options = {
+      timeZone: timezone,
+    };
+  }
+
+  return new Date(timestamp).toLocaleString('en-US', options);
+}
+
+export function dateByTimezone(
+  timestamp: number,
+  timezone: string,
+  format: string,
+): string {
+  const datetime = dateTimeByTimezone(timestamp, timezone);
+
+  return dayjs(datetime).format(format || 'mm/dd/yyyy');
+}
+
+export const dateByTimestamp = (timestamp: Timestamp, format: string): string => {
+  const datetime = new Date(timestamp).toLocaleString('en-US');
+
+  return dayjs(datetime).format(format || 'mm/dd/yyyy');
+};
+
+export function convertTimeStampToSeconds(timeStamp: Timestamp): number {
+  const demoTimeStamp = timeStamp;
+  const currentTimeStamp = getCurrentTimestamp();
+
+  if (Number.isNaN(demoTimeStamp) || Number.isNaN(currentTimeStamp)) {
+    return timeStamp;
+  }
+
+  const demoTimeStampLength = String(demoTimeStamp).length;
+  const currentTimeStampLength = String(currentTimeStamp).length;
+
+  return demoTimeStampLength > currentTimeStampLength ? timeStamp / 1000 : timeStamp;
+}
+
+export function formatTimestamp(datetime: Timestamp, format: string | undefined): string {
+  const timeStamp = convertTimeStampToSeconds(datetime);
+
+  return dayjs.unix(timeStamp).format(format);
+}
+
+export function getTimezone(): string {
+  return Intl?.DateTimeFormat().resolvedOptions().timeZone;
+}
+
+export function timeToX(
+  datetime: string | number | Date | dayjs.Dayjs | null | undefined,
+): string {
+  dayjs.extend(relativeTime);
+
+  return dayjs().to(datetime, true);
+}
+
+export function getCurrentDatebyTimezone(timezone: string): string {
+  let options = {};
+
+  if (timezone) {
+    options = {
+      timeZone: timezone,
+    };
+  }
+
+  return new Date().toLocaleString('en-US', options);
+}
+
+export function getTimeDiff(
+  date1: string | number | Date | dayjs.Dayjs | null | undefined,
+  date2: string | number | Date | dayjs.Dayjs | null | undefined,
+): { days: any; hour: any; minute: any; seconds: any; distance: any } {
+  const dateTime1 = dayjs(date1);
+  const dateTime2 = dayjs(date2);
+
+  return {
+    days: dateTime1.diff(dateTime2, 'days'),
+    hour: dateTime1.diff(dateTime2, 'hour'),
+    minute: dateTime1.diff(dateTime2, 'minute'),
+    seconds: dateTime1.diff(dateTime2, 'seconds'),
+    distance: dateTime1.diff(dateTime2),
+  };
+}
+
+export function getISOTimeString(demoTs: number): string {
+  return new Date(demoTs * 1000).toISOString().replace(/-|:|\.\d\d\d/g, '');
+}
+
+export function getDateAfterDays(days: number): string {
+  return formatDateTime(dayjs().add(days, 'day'), 'D MMM, YYYY').toUpperCase();
+}
+
+export const convertedTimezone = (selectedTimezone: string): string => {
+  const formattedTimezone = timezones?.find(
+    currentTimezone => currentTimezone?.id === selectedTimezone,
+  );
+
+  return formattedTimezone?.value ?? selectedTimezone?.replaceAll('_', ' ');
+};
+
+export const convertSecondsToMiliseconds = (seconds: number) => {
+  return seconds * 1000;
+};

package/src/growth-source/index.ts

@@ -1,5 +1,6 @@
 import type {
   SourceDetails,
+  SourceDetailsCookie,
   Platform,
   SignupFlow,
   UTMParams,
@@ -18,13 +19,13 @@ const UTM_PARAMS: UTMParamsKeys[] = [
   'utm_term',
 ];
 
-export const readSourceCookie = (): SourceDetails => {
+export const readSourceCookie = (): SourceDetailsCookie => {
   const sourceDetails = getCookie(SOURCE_DETAILS_COOKIE);
 
   return sourceDetails ? JSON.parse(decodeURIComponent(sourceDetails)) : undefined;
 };
 
-const writeSourceCookie = (sourceDetails: SourceDetails): void => {
+const writeSourceCookie = (sourceDetails: SourceDetailsCookie): void => {
   createCookie(SOURCE_DETAILS_COOKIE, JSON.stringify(sourceDetails), 365, true);
 };
 
@@ -32,11 +33,11 @@ export const isSourcePresent = (): boolean => {
   return !!getCookie(SOURCE_DETAILS_COOKIE);
 };
 
-const updateSourceCookie = (sourceDetail: Partial<SourceDetails>): void => {
+const updateSourceCookie = (sourceDetail: Partial<SourceDetailsCookie>): void => {
   if (!isSourcePresent) return;
 
-  const sourceDetails: SourceDetails = readSourceCookie();
-  const updatedDetails: SourceDetails = {
+  const sourceDetails: SourceDetailsCookie = readSourceCookie();
+  const updatedDetails: SourceDetailsCookie = {
     ...sourceDetails,
     ...sourceDetail,
   };
@@ -163,17 +164,17 @@ export const initSourceDetails = async ({
     performanceChannel =
       revenueChannel === 'performance' ? performanceChannel || leadChannel : undefined;
 
-    const sourceDetails: SourceDetails = {
-      platform,
-      experiments,
-      utmParams: getUTMParams(),
+    const sourceDetails: SourceDetailsCookie = {
+      platform_channel: platform,
+      experiment_dict: experiments,
+      utm_params: getUTMParams(),
       flow: flow || getFlow(platform, experiments),
-      affiliateChannel,
-      offlineChannel,
-      organicChannel,
-      performanceChannel,
-      revenueChannel: revenueChannel,
-      firstPage: getFirstPage(),
+      affiliate_channel: affiliateChannel,
+      offline_channel: offlineChannel,
+      organic_channel: organicChannel,
+      performance_channel: performanceChannel,
+      revenue_channel: revenueChannel,
+      first_page: getFirstPage(),
     };
 
     writeSourceCookie(sourceDetails);
@@ -182,10 +183,10 @@ export const initSourceDetails = async ({
 
 // Last Page which user visited signup before
 export const setLastPage = async (pagePath: string): Promise<void> => {
-  updateSourceCookie({ lastPage: pagePath });
+  updateSourceCookie({ last_page: pagePath });
 };
 
 // set Entry point where user clicked to Signup
 export const setFlowEntryPoint = async (flowEntry: string): Promise<void> => {
-  updateSourceCookie({ flowEntry });
+  updateSourceCookie({ flow_entry: flowEntry });
 };

package/src/growth-source/types.ts

@@ -17,9 +17,24 @@ export type UTMParams = {
 
 export type UTMParamsKeys = keyof UTMParams;
 
+export type SourceDetailsCookie = {
+  platform_channel: Platform;
+  experiment_dict?: Experiments;
+  flow?: SignupFlow;
+  utm_params?: UTMParams;
+  affiliate_channel?: string;
+  offline_channel?: string;
+  performance_channel?: string;
+  revenue_channel: RevenueChannel;
+  organic_channel?: string;
+  flow_entry?: string;
+  first_page?: string;
+  last_page?: string;
+};
+
 export type SourceDetails = {
   platform: Platform;
-  experiments?: Experiments;
+  experiments: Experiments;
   flow?: SignupFlow;
   utmParams?: UTMParams;
   affiliateChannel?: string;

package/src/index.ts

@@ -1,2 +1,6 @@
 export * from './cookie';
+export * from './constants';
+export * from './local-storage';
+export * from './date-time-helper';
+export * from './object';
 export * from './growth-source';

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;
+}