@cuemath/web-utils 1.0.7-santosh.5 → 1.0.7-santosh.8

package/.eslintignore

@@ -0,0 +1,2 @@
+.next
+/dist

package/.eslintrc.json

@@ -0,0 +1,9 @@
+{
+  "root": true,
+  "extends": ["@cuemath"],
+  "settings": {
+    "react": {
+      "version": "16.13.1"
+    }
+  }
+}

package/.husky/pre-commit

@@ -0,0 +1,5 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+yarn lint
+npx lint-staged

package/.huskyrc

@@ -0,0 +1,5 @@
+{
+  "hooks": {
+    "pre-commit": "lint-staged"
+  }
+}

package/.lintstagedrc.yml

@@ -0,0 +1 @@
+{ './**/*.js': ['prettier --write', 'eslint'] }

package/.nvmrc

@@ -0,0 +1 @@
+v18.12.1

package/.prettierrc.json

@@ -0,0 +1 @@
+"@cuemath/prettier-config"

package/.vscode/settings.json

@@ -0,0 +1 @@
+{}

package/package.json

@@ -1,9 +1,7 @@
 {
   "name": "@cuemath/web-utils",
-  "version": "1.0.7-santosh.5",
+  "version": "1.0.7-santosh.8",
   "description": "Shared web utils package",
-  "main": "dist/cjs/index.js",
-  "module": "dist/esm/index.js",
   "types": "dist/types/index.d.ts",
   "exports": {
     "./growth-source": "./dist/cjs/growth-source/index.js",
@@ -13,9 +11,6 @@
     "./growth-source": "./dist/esm/growth-source/index.js",
     ".": "./dist/esm/index.js"
   },
-  "files": [
-    "dist"
-  ],
   "scripts": {
     "lint": "tsc --noEmit && eslint 'src/**/*.{js,jsx,ts,tsx,json}'",
     "build:cjs": "tsc --project tsconfig.json",

package/src/constants/country/index.ts

@@ -0,0 +1 @@
+export { COUNTRY_NAME_COUNTRY_CODE_MAP as ISO_COUNTRY_CODE } from './iso-country-code';

package/src/constants/country/iso-country-code.ts

@@ -0,0 +1,248 @@
+export const COUNTRY_NAME_COUNTRY_CODE_MAP = {
+  'AFGHANISTAN': 'AF',
+  'ALAND ISLANDS': 'AX',
+  'ALBANIA': 'AL',
+  'ALGERIA': 'DZ',
+  'AMERICAN SAMOA': 'AS',
+  'ANDORRA': 'AD',
+  'ANGOLA': 'AO',
+  'ANGUILLA': 'AI',
+  'ANTARCTICA': 'AQ',
+  'ANTIGUA AND BARBUDA': 'AG',
+  'ARGENTINA': 'AR',
+  'ARMENIA': 'AM',
+  'ARUBA': 'AW',
+  'AUSTRALIA': 'AU',
+  'AUSTRIA': 'AT',
+  'AZERBAIJAN': 'AZ',
+  'BAHAMAS': 'BS',
+  'BAHRAIN': 'BH',
+  'BANGLADESH': 'BD',
+  'BARBADOS': 'BB',
+  'BELARUS': 'BY',
+  'BELGIUM': 'BE',
+  'BELIZE': 'BZ',
+  'BENIN': 'BJ',
+  'BERMUDA': 'BM',
+  'BHUTAN': 'BT',
+  'BOLIVIA': 'BO',
+  'BOSNIA AND HERZEGOVINA': 'BA',
+  'BOTSWANA': 'BW',
+  'BOUVET ISLAND': 'BV',
+  'BRAZIL': 'BR',
+  'BRITISH INDIAN OCEAN TERRITORY': 'IO',
+  'BRUNEI DARUSSALAM': 'BN',
+  'BULGARIA': 'BG',
+  'BURKINA FASO': 'BF',
+  'BURUNDI': 'BI',
+  'CAMBODIA': 'KH',
+  'CAMEROON': 'CM',
+  'CANADA': 'CA',
+  'CAPE VERDE': 'CV',
+  'CAYMAN ISLANDS': 'KY',
+  'CENTRAL AFRICAN REPUBLIC': 'CF',
+  'CHAD': 'TD',
+  'CHILE': 'CL',
+  'CHINA': 'CN',
+  'CHRISTMAS ISLAND': 'CX',
+  'COCOS (KEELING) ISLANDS': 'CC',
+  'COLOMBIA': 'CO',
+  'COMOROS': 'KM',
+  'CONGO': 'CG',
+  'CONGO, DEMOCRATIC REPUBLIC': 'CD',
+  'COOK ISLANDS': 'CK',
+  'COSTA RICA': 'CR',
+  'COTE D"IVOIRE': 'CI',
+  'CROATIA': 'HR',
+  'CUBA': 'CU',
+  'CYPRUS': 'CY',
+  'CZECH REPUBLIC': 'CZ',
+  'DENMARK': 'DK',
+  'DJIBOUTI': 'DJ',
+  'DOMINICA': 'DM',
+  'DOMINICAN REPUBLIC': 'DO',
+  'ECUADOR': 'EC',
+  'EGYPT': 'EG',
+  'EL SALVADOR': 'SV',
+  'EQUATORIAL GUINEA': 'GQ',
+  'ERITREA': 'ER',
+  'ESTONIA': 'EE',
+  'ETHIOPIA': 'ET',
+  'FALKLAND ISLANDS (MALVINAS)': 'FK',
+  'FAROE ISLANDS': 'FO',
+  'FIJI': 'FJ',
+  'FINLAND': 'FI',
+  'FRANCE': 'FR',
+  'FRENCH GUIANA': 'GF',
+  'FRENCH POLYNESIA': 'PF',
+  'FRENCH SOUTHERN TERRITORIES': 'TF',
+  'GABON': 'GA',
+  'GAMBIA': 'GM',
+  'GEORGIA': 'GE',
+  'GERMANY': 'DE',
+  'GHANA': 'GH',
+  'GIBRALTAR': 'GI',
+  'GREECE': 'GR',
+  'GREENLAND': 'GL',
+  'GRENADA': 'GD',
+  'GUADELOUPE': 'GP',
+  'GUAM': 'GU',
+  'GUATEMALA': 'GT',
+  'GUERNSEY': 'GG',
+  'GUINEA': 'GN',
+  'GUINEA-BISSAU': 'GW',
+  'GUYANA': 'GY',
+  'HAITI': 'HT',
+  'HEARD ISLAND & MCDONALD ISLANDS': 'HM',
+  'HOLY SEE (VATICAN CITY STATE)': 'VA',
+  'HONDURAS': 'HN',
+  'HONG KONG': 'HK',
+  'HUNGARY': 'HU',
+  'ICELAND': 'IS',
+  'INDIA': 'IN',
+  'INDONESIA': 'ID',
+  'IRAN, ISLAMIC REPUBLIC OF': 'IR',
+  'IRAQ': 'IQ',
+  'IRELAND': 'IE',
+  'ISLE OF MAN': 'IM',
+  'ISRAEL': 'IL',
+  'ITALY': 'IT',
+  'JAMAICA': 'JM',
+  'JAPAN': 'JP',
+  'JERSEY': 'JE',
+  'JORDAN': 'JO',
+  'KAZAKHSTAN': 'KZ',
+  'KENYA': 'KE',
+  'KIRIBATI': 'KI',
+  'KOREA': 'KR',
+  'NORTH KOREA': 'KP',
+  'KUWAIT': 'KW',
+  'KYRGYZSTAN': 'KG',
+  'LAO PEOPLE"S DEMOCRATIC REPUBLIC': 'LA',
+  'LATVIA': 'LV',
+  'LEBANON': 'LB',
+  'LESOTHO': 'LS',
+  'LIBERIA': 'LR',
+  'LIBYAN ARAB JAMAHIRIYA': 'LY',
+  'LIECHTENSTEIN': 'LI',
+  'LITHUANIA': 'LT',
+  'LUXEMBOURG': 'LU',
+  'MACAO': 'MO',
+  'MACEDONIA': 'MK',
+  'MADAGASCAR': 'MG',
+  'MALAWI': 'MW',
+  'MALAYSIA': 'MY',
+  'MALDIVES': 'MV',
+  'MALI': 'ML',
+  'MALTA': 'MT',
+  'MARSHALL ISLANDS': 'MH',
+  'MARTINIQUE': 'MQ',
+  'MAURITANIA': 'MR',
+  'MAURITIUS': 'MU',
+  'MAYOTTE': 'YT',
+  'MEXICO': 'MX',
+  'MICRONESIA, FEDERATED STATES OF': 'FM',
+  'MOLDOVA': 'MD',
+  'MONACO': 'MC',
+  'MONGOLIA': 'MN',
+  'MONTENEGRO': 'ME',
+  'MONTSERRAT': 'MS',
+  'MOROCCO': 'MA',
+  'MOZAMBIQUE': 'MZ',
+  'MYANMAR': 'MM',
+  'NAMIBIA': 'NA',
+  'NAURU': 'NR',
+  'NEPAL': 'NP',
+  'NETHERLANDS': 'NL',
+  'NETHERLANDS ANTILLES': 'AN',
+  'NEW CALEDONIA': 'NC',
+  'NEW ZEALAND': 'NZ',
+  'NICARAGUA': 'NI',
+  'NIGER': 'NE',
+  'NIGERIA': 'NG',
+  'NIUE': 'NU',
+  'NORFOLK ISLAND': 'NF',
+  'NORTHERN MARIANA ISLANDS': 'MP',
+  'NORWAY': 'NO',
+  'OMAN': 'OM',
+  'PAKISTAN': 'PK',
+  'PALAU': 'PW',
+  'PALESTINIAN TERRITORY, OCCUPIED': 'PS',
+  'PANAMA': 'PA',
+  'PAPUA NEW GUINEA': 'PG',
+  'PARAGUAY': 'PY',
+  'PERU': 'PE',
+  'PHILIPPINES': 'PH',
+  'PITCAIRN': 'PN',
+  'POLAND': 'PL',
+  'PORTUGAL': 'PT',
+  'PUERTO RICO': 'PR',
+  'QATAR': 'QA',
+  'REUNION': 'RE',
+  'ROMANIA': 'RO',
+  'RUSSIAN FEDERATION': 'RU',
+  'RWANDA': 'RW',
+  'SAINT BARTHELEMY': 'BL',
+  'SAINT HELENA': 'SH',
+  'SAINT KITTS AND NEVIS': 'KN',
+  'SAINT LUCIA': 'LC',
+  'SAINT MARTIN': 'MF',
+  'SAINT PIERRE AND MIQUELON': 'PM',
+  'SAINT VINCENT AND GRENADINES': 'VC',
+  'SAMOA': 'WS',
+  'SAN MARINO': 'SM',
+  'SAO TOME AND PRINCIPE': 'ST',
+  'SAUDI ARABIA': 'SA',
+  'SENEGAL': 'SN',
+  'SERBIA': 'RS',
+  'SEYCHELLES': 'SC',
+  'SIERRA LEONE': 'SL',
+  'SINGAPORE': 'SG',
+  'SLOVAKIA': 'SK',
+  'SLOVENIA': 'SI',
+  'SOLOMON ISLANDS': 'SB',
+  'SOMALIA': 'SO',
+  'SOUTH AFRICA': 'ZA',
+  'SOUTH GEORGIA AND SANDWICH ISL.': 'GS',
+  'SPAIN': 'ES',
+  'SRI LANKA': 'LK',
+  'SUDAN': 'SD',
+  'SURINAME': 'SR',
+  'SVALBARD AND JAN MAYEN': 'SJ',
+  'SWAZILAND': 'SZ',
+  'SWEDEN': 'SE',
+  'SWITZERLAND': 'CH',
+  'SYRIAN ARAB REPUBLIC': 'SY',
+  'TAIWAN': 'TW',
+  'TAJIKISTAN': 'TJ',
+  'TANZANIA': 'TZ',
+  'THAILAND': 'TH',
+  'TIMOR-LESTE': 'TL',
+  'TOGO': 'TG',
+  'TOKELAU': 'TK',
+  'TONGA': 'TO',
+  'TRINIDAD AND TOBAGO': 'TT',
+  'TUNISIA': 'TN',
+  'TURKEY': 'TR',
+  'TURKMENISTAN': 'TM',
+  'TURKS AND CAICOS ISLANDS': 'TC',
+  'TUVALU': 'TV',
+  'UGANDA': 'UG',
+  'UKRAINE': 'UA',
+  'UNITED ARAB EMIRATES': 'AE',
+  'UNITED KINGDOM': 'GB',
+  'UNITED STATES': 'US',
+  'UNITED STATES OUTLYING ISLANDS': 'UM',
+  'URUGUAY': 'UY',
+  'UZBEKISTAN': 'UZ',
+  'VANUATU': 'VU',
+  'VENEZUELA': 'VE',
+  'VIETNAM': 'VN',
+  'VIRGIN ISLANDS, BRITISH': 'VG',
+  'VIRGIN ISLANDS, U.S.': 'VI',
+  'WALLIS AND FUTUNA': 'WF',
+  'WESTERN SAHARA': 'EH',
+  'YEMEN': 'YE',
+  'ZAMBIA': 'ZM',
+  'ZIMBABWE': 'ZW',
+};

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

@@ -0,0 +1,45 @@
+export { timezones } from './international-timezones';
+
+export const DAY = {
+  Sun: 'Sunday',
+  Mon: 'Monday',
+  Tue: 'Tuesday',
+  Wed: 'Wednesday',
+  Thu: 'Thursday',
+  Fri: 'Friday',
+  Sat: 'Saturday',
+};
+
+export const shorthandWeekDayArray = ['Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa', 'Su'];
+
+export const MONTH_ARRAY = [
+  'Jan',
+  'Feb',
+  'Mar',
+  'Apr',
+  'May',
+  'Jun',
+  'Jul',
+  'Aug',
+  'Sept',
+  'Oct',
+  'Nov',
+  'Dec',
+];
+
+export const weekDayArray: string[] = [
+  'Sunday',
+  'Monday',
+  'Tuesday',
+  'Wednesday',
+  'Thursday',
+  'Friday',
+  'Saturday',
+];
+
+export const TWENTY_FOUR_HOURS_IN_SECONDS: number = 24 * 60 * 60; // 86400
+
+export const HOUR_FORMAT = {
+  TWELVE_HOUR_FORMAT: 12,
+  TWENTY_FOUR_HOUR_FORMAT: 24,
+};

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,2 @@
+export * from './country';
+export * from './date-time';

package/src/cookie/index.ts

@@ -0,0 +1,59 @@
+export const getCookie = (name: string, cookie: string = document.cookie): string => {
+  if (!cookie) {
+    return '';
+  }
+
+  const cookies = cookie.split('; ');
+
+  for (let i = 0; i < cookies.length; i += 1) {
+    if (cookies[i]) {
+      const [key, value] = cookies[i].split('=');
+
+      if (key === name) {
+        return value;
+      }
+    }
+  }
+
+  return '';
+};
+
+export function removeCookie(name: string, subdomain?: boolean): void {
+  const date = new Date();
+
+  // Set it expire in -1 days
+  date.setTime(date.getTime() + -1 * 24 * 60 * 60 * 1000);
+
+  // Set it
+  document.cookie = `${name}=; expires=${date.toUTCString()}; path=/${
+    subdomain ? '; domain=cuemath.com' : ''
+  }`;
+}
+
+export function createCookie(
+  name: string,
+  value: string,
+  days: number,
+  subdomain?: boolean,
+): void {
+  let expires = '';
+
+  if (days) {
+    const date = new Date();
+
+    date.setTime(date.getTime() + days * 24 * 60 * 60 * 1000);
+    expires = `; expires=${date.toUTCString()}`;
+  }
+  document.cookie = `${name}=${encodeURIComponent(value)}${expires}; path=/${
+    subdomain ? '; domain=cuemath.com' : ''
+  }`;
+}
+
+export function createCookieWithMidnightExp(name: string, value: string): void {
+  const date = new Date();
+
+  date.setHours(24, 0, 0, 0);
+  const expires = `; expires=${date}`;
+
+  document.cookie = `${name}=${value}${expires}; path=/`;
+}

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?.replace(/_/g, ' ');
+};
+
+export const convertSecondsToMiliseconds = (seconds: number) => {
+  return seconds * 1000;
+};

package/src/e-cna/index.ts

@@ -0,0 +1,23 @@
+import { TWENTY_FOUR_HOURS_IN_SECONDS } from '../constants/date-time';
+import { getCurrentDatebyTimezone } from '../date-time-helper/index';
+
+// if adding any change in this function, then need update at all the places where we are using this function in website and astro
+export const getDates = (
+  timezone: string,
+): Array<{ futureDate: number; disabled: boolean }> => {
+  const currentDate = Date.parse(getCurrentDatebyTimezone(timezone)) / 1000;
+  const dates = [];
+
+  const days = 10;
+  const buffer = 2;
+
+  // 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/growth-source/index.ts

@@ -0,0 +1,235 @@
+import type {
+  SourceDetails,
+  SourceDetailsCookie,
+  Platform,
+  SignupFlow,
+  UTMParams,
+  Experiments,
+  RevenueChannel,
+  UTMParamsKeys,
+} from './types';
+
+import { createCookie, getCookie, removeCookie } from '../cookie';
+
+const SOURCE_DETAILS_COOKIE = 'source_details';
+const UTM_PARAMS: UTMParamsKeys[] = [
+  'utm_source',
+  'utm_medium',
+  'utm_campaign',
+  'utm_term',
+];
+
+export const readSourceCookie = (): SourceDetailsCookie => {
+  const sourceDetails = getCookie(SOURCE_DETAILS_COOKIE);
+
+  return sourceDetails ? JSON.parse(decodeURIComponent(sourceDetails)) : undefined;
+};
+
+const writeSourceCookie = (sourceDetails: SourceDetailsCookie): void => {
+  createCookie(SOURCE_DETAILS_COOKIE, JSON.stringify(sourceDetails), 365);
+};
+
+export const isSourcePresent = (): boolean => {
+  return !!getCookie(SOURCE_DETAILS_COOKIE);
+};
+
+const updateSourceCookie = (sourceDetail: Partial<SourceDetailsCookie>): void => {
+  if (!isSourcePresent) return;
+
+  const sourceDetails: SourceDetailsCookie = readSourceCookie();
+  const updatedDetails: SourceDetailsCookie = {
+    ...sourceDetails,
+    ...sourceDetail,
+  };
+
+  writeSourceCookie(updatedDetails);
+};
+
+const getRevenueChannel = (platform: Platform, utmSource?: string): RevenueChannel => {
+  let revenueChannel: RevenueChannel = 'unknown';
+
+  // set defaults for WEBSITE and ASTRO
+  if (platform === 'website') {
+    revenueChannel = 'organic';
+  } else if (platform === 'astro') {
+    revenueChannel = 'performance';
+  }
+
+  if (utmSource) {
+    switch (true) {
+      case /^affiliate-/.test(utmSource):
+        revenueChannel = 'affiliate';
+        break;
+      case /^offline-/.test(utmSource):
+        revenueChannel = 'offline';
+        break;
+      case /^referral-/.test(utmSource):
+        revenueChannel = 'referral';
+        break;
+      case /^performance-/.test(utmSource):
+        revenueChannel = 'performance';
+        break;
+    }
+  }
+
+  return revenueChannel;
+};
+
+/*
+  if Platform = website, then decide based on experiment key
+  if Platform = Astro, decide logic once BAU is started
+  if Platform = APP, decide logic
+  if Platform = chatbot, decide based on chatbot experiment key
+*/
+const getFlow = (platform: Platform, experiments?: Experiments): SignupFlow => {
+  let flow: SignupFlow = 'regular';
+
+  if (platform === 'website') {
+    if (experiments) {
+      const ecnaExp = Object.keys(experiments).find(
+        experiment => experiment.indexOf('ecna') !== -1,
+      );
+
+      flow = ecnaExp && experiments[ecnaExp] === 'b' ? 'e-cna' : 'regular';
+    }
+  }
+
+  return flow;
+};
+
+const getUTMParams = (): Partial<UTMParams> => {
+  if (typeof window === undefined) return {};
+
+  const search = new URLSearchParams(window.location.search);
+  const utmParams = UTM_PARAMS.reduce((acc: UTMParams, param) => {
+    const utmParam = search.get(param) as string;
+
+    if (utmParam) {
+      acc[param] = utmParam;
+    }
+
+    return acc;
+  }, {});
+
+  return utmParams;
+};
+
+const getFirstPage = (): string => {
+  if (typeof window === undefined) return '';
+
+  return window.location.pathname;
+};
+
+/* TODO: Align Marketing Team on UTM source convention
+  affiliate-<channel>
+  performance-<channel>
+  organic-<channel>
+  offline-<channel>
+*/
+const getChannel = (utmSource?: string): string => {
+  // TODO: UTM source patter for FB, GOOGLE...
+  if (!utmSource) return '';
+
+  let channel = '';
+
+  if (utmSource) {
+    switch (true) {
+      case /^affiliate-/.test(utmSource):
+      case /^offline-/.test(utmSource):
+      case /^referral-/.test(utmSource):
+      case /^performance-/.test(utmSource):
+        channel = utmSource.split('-')[1];
+        break;
+      default:
+        break;
+    }
+  }
+
+  return channel;
+};
+
+/* 
+  Set Static Source Details of user on Visit of Platform
+*/
+export const initSourceDetails = async ({
+  platform,
+  experiments,
+  flow,
+  affiliateChannel,
+  offlineChannel,
+  organicChannel,
+  performanceChannel,
+  revenueChannel,
+  guestId,
+}: SourceDetails): Promise<void> => {
+  const utmParams: Partial<UTMParams> = getUTMParams();
+  const { utm_source: utmSource } = utmParams;
+  const leadChannel = getChannel(utmSource);
+
+  /*
+    source cookie was added in cross subdomain for few days initially,
+    which was later changed to subdomain specific. Now to sending older cookie to backend, removing older cookie
+  */
+  removeCookie(SOURCE_DETAILS_COOKIE, true);
+
+  revenueChannel = revenueChannel || getRevenueChannel(platform, utmSource);
+
+  if (utmSource) {
+    affiliateChannel =
+      revenueChannel === 'affiliate' ? affiliateChannel || leadChannel : undefined;
+    offlineChannel =
+      revenueChannel === 'offline' ? offlineChannel || leadChannel : undefined;
+    organicChannel =
+      revenueChannel === 'organic' ? organicChannel || leadChannel : undefined;
+    performanceChannel =
+      revenueChannel === 'performance' ? performanceChannel || leadChannel : undefined;
+  }
+
+  if (!isSourcePresent()) {
+    const sourceDetails: SourceDetailsCookie = {
+      platform_channel: platform,
+      experiment_dict: experiments,
+      utm_params: utmParams,
+      flow: flow || getFlow(platform, experiments),
+      affiliate_channel: affiliateChannel,
+      offline_channel: offlineChannel,
+      organic_channel: organicChannel,
+      performance_channel: performanceChannel,
+      revenue_channel: revenueChannel,
+      first_page: getFirstPage(),
+      guest_id: guestId,
+    };
+
+    writeSourceCookie(sourceDetails);
+  } else {
+    let updatedSource: Partial<SourceDetailsCookie> = {
+      experiment_dict: experiments,
+      flow: flow || getFlow(platform, experiments),
+      guest_id: guestId,
+    };
+
+    if (utmSource) {
+      updatedSource = {
+        ...updatedSource,
+        utm_params: utmParams,
+        affiliate_channel: affiliateChannel,
+        offline_channel: offlineChannel,
+        organic_channel: organicChannel,
+        performance_channel: performanceChannel,
+        revenue_channel: revenueChannel,
+      };
+    }
+
+    updateSourceCookie(updatedSource);
+  }
+};
+
+// Last Page which user visited signup before
+export const setLastPage = async (pagePath: string): Promise<void> => {
+  updateSourceCookie({ last_page: pagePath });
+};
+
+// set Entry point where user clicked to Signup
+export const setFlowEntryPoint = async (flowEntry: string): Promise<void> => {
+  updateSourceCookie({ flow_entry: flowEntry });
+};

package/src/growth-source/types.ts

@@ -0,0 +1,50 @@
+export type Platform = 'website' | 'app' | 'astro' | 'leap-teacher' | 'leap-admin';
+export type RevenueChannel =
+  | 'organic'
+  | 'performance'
+  | 'affiliate'
+  | 'offline'
+  | 'referral'
+  | 'unknown';
+export type SignupFlow = 'regular' | 'e-cna' | 'e-sales';
+export type Experiments = Record<string, unknown>;
+export type UTMParams = {
+  utm_source?: string;
+  utm_medium?: string;
+  utm_campaign?: string;
+  utm_term?: string;
+};
+
+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;
+  guest_id?: string;
+};
+
+export type SourceDetails = {
+  platform: Platform;
+  experiments: Experiments;
+  flow?: SignupFlow;
+  utmParams?: UTMParams;
+  affiliateChannel?: string;
+  offlineChannel?: string;
+  performanceChannel?: string;
+  revenueChannel: RevenueChannel;
+  organicChannel?: string;
+  flowEntry?: string;
+  firstPage?: string;
+  lastPage?: string;
+  guestId?: string;
+};

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from './cookie';
+export * from './constants';
+export * from './local-storage';
+export * from './date-time-helper';
+export * from './object';
+export * from './growth-source';
+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;
+}

package/tsconfig.esm.json

@@ -0,0 +1,17 @@
+{
+    "extends": "@cuemath/ts-config/tsconfig.json",
+    "compilerOptions": {
+      "target": "es2015",
+      "module": "es6",
+      "outDir": "dist/esm",
+      "moduleResolution": "node",
+      "declaration": true,
+      "sourceMap": true,
+      "baseUrl": ".",
+      "paths": {
+        "growth-source": ["./src/growth-source"],
+      }
+    },
+    "include": ["src/**/*"],
+    "exclude": ["node_modules"]
+  }

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "@cuemath/ts-config/tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist/cjs",
+    "module": "CommonJS"
+  },
+  "include": ["src/**/*"]
+}