@cuemath/web-utils 1.0.1 → 1.0.3-beta.1

package/src/constants/date-time/international-timezones.ts

@@ -0,0 +1,157 @@
+interface Timezone {
+  id: string;
+  value: string;
+  meta: string;
+}
+
+export const timezones: Timezone[] = [
+  {
+    id: 'Pacific/Honolulu',
+    value: 'HST(GMT-10)',
+    meta: 'HST(GMT-10)',
+  },
+  {
+    id: 'America/Anchorage',
+    value: 'AST(GMT-9)',
+    meta: 'AST(GMT-9)',
+  },
+  {
+    id: 'America/Los_Angeles',
+    value: 'PST(GMT-8)',
+    meta: 'PST(GMT-8)',
+  },
+  {
+    id: 'America/Denver',
+    value: 'MST(GMT-7)',
+    meta: 'MST(GMT-7)',
+  },
+  {
+    id: 'America/Phoenix',
+    value: 'MST(GMT-7)',
+    meta: 'MST(GMT-7)',
+  },
+  {
+    id: 'America/Matamoros',
+    value: 'CST(GMT-6)',
+    meta: 'CST(GMT-6)',
+  },
+  {
+    id: 'America/New_York',
+    value: 'EST(GMT-5)',
+    meta: 'EST(GMT-5)',
+  },
+  {
+    id: 'America/Glace_Bay',
+    value: 'AST(GMT-4)',
+    meta: 'AST(GMT-4)',
+  },
+  {
+    id: 'America/St_Johns',
+    value: 'NST(GMT-3:30)',
+    meta: 'NST(GMT-3:30)',
+  },
+  {
+    id: 'America/Noronha',
+    value: 'FNT(GMT-2)',
+    meta: 'FNT(GMT-2)',
+  },
+  {
+    id: 'Asia/Calcutta',
+    value: 'IST(GMT+5:30)',
+    meta: 'IST(GMT+5:30)',
+  },
+  {
+    id: 'Asia/Kolkata',
+    value: 'IST(GMT+5:30)',
+    meta: 'IST(GMT+5:30)',
+  },
+  {
+    id: 'Asia/Dubai',
+    value: 'GST(GMT+4)',
+    meta: 'GST(GMT+4)',
+  },
+  {
+    id: 'Asia/Singapore',
+    value: 'SGT(GMT+8)',
+    meta: 'SGT(GMT+8)',
+  },
+  {
+    id: 'Pacific/Auckland',
+    value: 'NZDT(GMT+13)',
+    meta: 'NZDT(GMT+13)',
+  },
+  {
+    id: 'Australia/Adelaide',
+    value: 'ACDT(GMT+10:30)',
+    meta: 'ACDT(GMT+10:30)',
+  },
+  {
+    id: 'Australia/Perth',
+    value: 'AWST(GMT+8)',
+    meta: 'AWST(GMT+8)',
+  },
+  {
+    id: 'Australia/Sydney',
+    value: 'AEDT(GMT+11)',
+    meta: 'AEDT(GMT+11)',
+  },
+  {
+    id: 'Australia/Darwin',
+    value: 'ACST(GMT+9:30)',
+    meta: 'ACST(GMT+9:30)',
+  },
+  {
+    id: 'Australia/Broken_Hill',
+    value: 'ACDT(GMT+10:30)',
+    meta: 'ACDT(GMT+10:30)',
+  },
+  {
+    id: 'Australia/Melbourne',
+    value: 'AEDT(GMT+11)',
+    meta: 'AEDT(GMT+11)',
+  },
+  {
+    id: 'Australia/Brisbane',
+    value: 'AEST(GMT+10)',
+    meta: 'AEST(GMT+10)',
+  },
+  {
+    id: 'Australia/Hobart',
+    value: 'AEDT(GMT+11)',
+    meta: 'AEDT(GMT+11)',
+  },
+  {
+    id: 'Europe/London',
+    value: 'GMT(GMT+0)',
+    meta: 'GMT(GMT+0)',
+  },
+  {
+    id: 'Asia/Muscat',
+    value: 'GST(GMT+4)',
+    meta: 'GST(GMT+4)',
+  },
+  {
+    id: 'Asia/Kuwait',
+    value: 'AST(GMT+3)',
+    meta: 'AST(GMT+3)',
+  },
+  {
+    id: 'Asia/Bahrain',
+    value: 'AST(GMT+3)',
+    meta: 'AST(GMT+3)',
+  },
+  {
+    id: 'Asia/Qatar',
+    value: 'AST(GMT+3)',
+    meta: 'AST(GMT+3)',
+  },
+  {
+    id: 'Asia/Riyadh',
+    value: 'AST(GMT+3)',
+    meta: 'AST(GMT+3)',
+  },
+].map(timezone => ({
+  ...timezone,
+  key: timezone.id,
+  label: timezone.meta,
+}));

package/src/constants/index.ts

@@ -0,0 +1 @@
+export * from './country';

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

@@ -0,0 +1,44 @@
+import { ISO_COUNTRY_CODE } from '../../constants/country/index';
+import { TWENTY_FOUR_HOURS_IN_SECONDS } from '../../constants/date-time';
+import { getCurrentDatebyTimezone } from '../index';
+
+export const getDates = (
+  timezone: string,
+  platform: string,
+  country: string,
+): Array<{ futureDate: number; disabled: boolean }> => {
+  const currentDate = Date.parse(getCurrentDatebyTimezone(timezone)) / 1000;
+  const dates = [];
+
+  let days = 7;
+  let buffer = 1;
+
+  switch (platform) {
+    case 'astro':
+      if (country === ISO_COUNTRY_CODE.INDIA) {
+        days = 10;
+        buffer = 2;
+      }
+      break;
+    case 'website':
+      if (country === ISO_COUNTRY_CODE.INDIA) {
+        days = 10;
+        buffer = 2;
+      }
+      break;
+    default:
+      days = 7;
+      buffer = 1;
+      break;
+  }
+
+  // getting dates by adding 86400 seconds(24 hours)
+  for (let i = 0; i < days; i += 1) {
+    dates.push({
+      futureDate: currentDate + TWENTY_FOUR_HOURS_IN_SECONDS * i,
+      disabled: !(i > buffer),
+    });
+  }
+
+  return dates;
+};

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/e-cna/index.ts

@@ -0,0 +1,8 @@
+import { COUNTRY_NAME_COUNTRY_CODE_MAP as ISO_COUNTRY_CODE } from '../constants/country/iso-country-code';
+import { getCookie } from '../cookie';
+
+export const showLaptopQuestion = () => {
+  const cueCountryCode = getCookie('cue_country_code');
+
+  return cueCountryCode === ISO_COUNTRY_CODE.INDIA;
+};

package/src/growth-source/index.ts

@@ -26,7 +26,7 @@ export const readSourceCookie = (): SourceDetailsCookie => {
 };
 
 const writeSourceCookie = (sourceDetails: SourceDetailsCookie): void => {
-  createCookie(SOURCE_DETAILS_COOKIE, JSON.stringify(sourceDetails), 365, true);
+  createCookie(SOURCE_DETAILS_COOKIE, JSON.stringify(sourceDetails), 365);
 };
 
 export const isSourcePresent = (): boolean => {
@@ -45,7 +45,7 @@ const updateSourceCookie = (sourceDetail: Partial<SourceDetailsCookie>): void =>
   writeSourceCookie(updatedDetails);
 };
 
-const getRevenueChannel = (platform: Platform, utmParams?: UTMParams): RevenueChannel => {
+const getRevenueChannel = (platform: Platform, utmSource?: string): RevenueChannel => {
   let revenueChannel: RevenueChannel = 'unknown';
 
   // set defaults for WEBSITE and ASTRO
@@ -55,9 +55,7 @@ const getRevenueChannel = (platform: Platform, utmParams?: UTMParams): RevenueCh
     revenueChannel = 'performance';
   }
 
-  if (utmParams) {
-    const { utm_source: utmSource = '' } = utmParams;
-
+  if (utmSource) {
     switch (true) {
       case /^affiliate-/.test(utmSource):
         revenueChannel = 'affiliate';
@@ -99,8 +97,8 @@ const getFlow = (platform: Platform, experiments?: Experiments): SignupFlow => {
   return flow;
 };
 
-const getUTMParams = (): UTMParams | undefined => {
-  if (typeof window === undefined) return;
+const getUTMParams = (): Partial<UTMParams> => {
+  if (typeof window === undefined) return {};
 
   const search = new URLSearchParams(window.location.search);
   const utmParams = UTM_PARAMS.reduce((acc: UTMParams, param) => {
@@ -128,11 +126,9 @@ const getFirstPage = (): string => {
   organic-<channel>
   offline-<channel>
 */
-const getChannel = (utmParams: UTMParams | undefined): string => {
+const getChannel = (utmSource?: string): string => {
   // TODO: UTM source patter for FB, GOOGLE...
-  if (!utmParams) return '';
-
-  const { utm_source: utmSource = '' } = utmParams;
+  if (!utmSource) return '';
 
   return utmSource.split('-')[1];
 };
@@ -150,11 +146,13 @@ export const initSourceDetails = async ({
   performanceChannel,
   revenueChannel,
 }: SourceDetails): Promise<void> => {
-  if (!isSourcePresent()) {
-    const utmParams = getUTMParams();
-    const leadChannel = getChannel(utmParams);
+  const utmParams: Partial<UTMParams> = getUTMParams();
+  const { utm_source: utmSource } = utmParams;
+  const leadChannel = getChannel(utmSource);
 
-    revenueChannel = revenueChannel || getRevenueChannel(platform, utmParams);
+  revenueChannel = revenueChannel || getRevenueChannel(platform, utmSource);
+
+  if (utmSource) {
     affiliateChannel =
       revenueChannel === 'affiliate' ? affiliateChannel || leadChannel : undefined;
     offlineChannel =
@@ -163,11 +161,13 @@ export const initSourceDetails = async ({
       revenueChannel === 'organic' ? organicChannel || leadChannel : undefined;
     performanceChannel =
       revenueChannel === 'performance' ? performanceChannel || leadChannel : undefined;
+  }
 
+  if (!isSourcePresent()) {
     const sourceDetails: SourceDetailsCookie = {
       platform_channel: platform,
       experiment_dict: experiments,
-      utm_params: getUTMParams(),
+      utm_params: utmParams,
       flow: flow || getFlow(platform, experiments),
       affiliate_channel: affiliateChannel,
       offline_channel: offlineChannel,
@@ -178,6 +178,25 @@ export const initSourceDetails = async ({
     };
 
     writeSourceCookie(sourceDetails);
+  } else {
+    let updatedSource: Partial<SourceDetailsCookie> = {
+      experiment_dict: experiments,
+      flow: flow || getFlow(platform, experiments),
+    };
+
+    if (utmSource) {
+      updatedSource = {
+        ...updatedSource,
+        utm_params: utmParams,
+        affiliate_channel: affiliateChannel,
+        offline_channel: offlineChannel,
+        organic_channel: organicChannel,
+        performance_channel: performanceChannel,
+        revenue_channel: revenueChannel,
+      };
+    }
+
+    updateSourceCookie(updatedSource);
   }
 };
 

package/src/index.ts

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

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,21 @@
+export function isEmpty(obj: object): boolean {
+  return Object.keys(obj).length === 0;
+}
+
+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;
+}