castled-js-sdk 0.0.1 → 0.0.2

package/src/utils/linker/base64decoder.js

@@ -0,0 +1,31 @@
+/**
+ * @description This is utility function for decoding from base 64 to utf8
+ * @version v1.0.0
+ */
+
+/**
+ * @param {string} str base64
+ * @returns {string} utf8
+ */
+function b64DecodeUnicode(str) {
+  // Going backwards: from bytestream, to percent-encoding, to original string.
+  return decodeURIComponent(
+    atob(str)
+      .split('')
+      .map(function (c) {
+        return `%${`00${c.charCodeAt(0).toString(16)}`.slice(-2)}`;
+      })
+      .join(''),
+  );
+}
+
+/**
+ * @param {string} value
+ * @return {string}
+ */
+function decode(data = '') {
+  data = data.endsWith('..') ? data.substr(0, data.length - 2) : data;
+  return b64DecodeUnicode(data);
+}
+
+export default decode;

package/src/utils/linker/crc32.js

@@ -0,0 +1,42 @@
+/* eslint-disable no-bitwise */
+/**
+ * @description This is utility function for crc32 algorithm
+ * @version v1.0.0
+ */
+
+/**
+ * @description generate crc table
+ * @params none
+ * @returns array of CRC table
+ */
+
+const makeCRCTable = function () {
+  const crcTable = [];
+  let c;
+  for (let n = 0; n < 256; n++) {
+    c = n;
+    for (let k = 0; k < 8; k++) {
+      c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    }
+    crcTable[n] = c;
+  }
+  return crcTable;
+};
+
+/**
+ *
+ * @param {string} str
+ * @returns {Bytestream} crc32
+ */
+const crc32 = function (str) {
+  const crcTable = makeCRCTable();
+  let crc = 0 ^ -1;
+
+  for (let i = 0; i < str.length; i++) {
+    crc = (crc >>> 8) ^ crcTable[(crc ^ str.charCodeAt(i)) & 0xff];
+  }
+
+  return (crc ^ -1) >>> 0;
+};
+
+export default crc32;

package/src/utils/linker/index.js

@@ -0,0 +1,134 @@
+/**
+ * @description AMP Linker Parser (works for Rudder, GA or any other linker created by following Google's linker standard.)
+ * @version v1.0.0
+ * @author Parth Mahajan, Ayush Mehra
+ */
+
+import crc32 from './crc32';
+import USER_INTERFACE from './userLib';
+import decode from './base64decoder';
+
+const KEY_VALIDATOR = /^[a-zA-Z0-9\-_.]+$/;
+const CHECKSUM_OFFSET_MAX_MIN = 1;
+const VALID_VERSION = 1;
+const DELIMITER = '*';
+
+/**
+ * Parse the linker param value to version checksum and serializedParams
+ * @param {string} value
+ * @return {?Object}
+ */
+function parseLinkerParamValue(value) {
+  const parts = value.split(DELIMITER);
+  const isEven = parts.length % 2 === 0;
+
+  if (parts.length < 4 || !isEven) {
+    // Format <version>*<checksum>*<key1>*<value1>
+    // Note: linker makes sure there's at least one pair of non empty key value
+    // Make sure there is at least three delimiters.
+    return null;
+  }
+
+  const version = Number(parts.shift());
+  if (version !== VALID_VERSION) {
+    return null;
+  }
+
+  const checksum = parts.shift();
+  const serializedIds = parts.join(DELIMITER);
+  return {
+    checksum,
+    serializedIds,
+  };
+}
+
+/**
+ * Deserialize the serializedIds and return keyValue pairs.
+ * @param {string} serializedIds
+ * @return {!Object<string, string>}
+ */
+function deserialize(serializedIds) {
+  const keyValuePairs = {};
+  const params = serializedIds.split(DELIMITER);
+  for (let i = 0; i < params.length; i += 2) {
+    const key = params[i];
+    const valid = KEY_VALIDATOR.test(key);
+    if (valid) {
+      const value = decode(params[i + 1]);
+      // const value = params[i + 1];
+      keyValuePairs[key] = value;
+    }
+  }
+  return keyValuePairs;
+}
+
+/**
+ * Generates a semi-unique value for page visitor.
+ * @return {string}
+ */
+function getFingerprint(userAgent, language) {
+  const date = new Date();
+  const timezone = date.getTimezoneOffset();
+  return [userAgent, timezone, language].join(DELIMITER);
+}
+
+/**
+ * Rounded time used to check if t2 - t1 is within our time tolerance.
+ * @return {number}
+ */
+function getMinSinceEpoch() {
+  // Timestamp in minutes, floored.
+  return Math.floor(Date.now() / 60000);
+}
+
+/**
+ * Create a unique checksum hashing the fingerprint and a few other values.
+ * @param {string} serializedIds
+ * @param {number=} optOffsetMin
+ * @return {string}
+ */
+function getCheckSum(serializedIds, optOffsetMin, userAgent, language) {
+  const fingerprint = getFingerprint(userAgent, language);
+  const offset = optOffsetMin || 0;
+  const timestamp = getMinSinceEpoch() - offset;
+  const crc = crc32([fingerprint, timestamp, serializedIds].join(DELIMITER));
+  // Encoded to base36 for less bytes.
+  return crc.toString(36);
+}
+
+/**
+ * Check if the checksum is valid with time offset tolerance.
+ * @param {string} serializedIds
+ * @param {string} checksum
+ * @return {boolean}
+ */
+function isCheckSumValid(serializedIds, checksum) {
+  const userAgent = USER_INTERFACE.getUserAgent();
+  const language = USER_INTERFACE.getUserLanguage();
+  for (let i = 0; i <= CHECKSUM_OFFSET_MAX_MIN; i += 1) {
+    const calculateCheckSum = getCheckSum(serializedIds, i, userAgent, language);
+    if (calculateCheckSum === checksum) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Return the key value pairs
+ * @param {string} value
+ * @return {?Object<string, string>}
+ */
+function parseLinker(value) {
+  const linkerObj = parseLinkerParamValue(value);
+  if (!linkerObj) {
+    return null;
+  }
+  const { checksum, serializedIds } = linkerObj;
+  if (!isCheckSumValid(serializedIds, checksum)) {
+    return null;
+  }
+  return deserialize(serializedIds);
+}
+
+export default parseLinker;

package/src/utils/linker/userLib.js

@@ -0,0 +1,20 @@
+/**
+ * @description An interface to fetch user device details.
+ * @version v1.0.0
+ */
+
+const USER_INTERFACE = {
+  /**
+   * @param {*} req
+   * @returns {string} user language
+   */
+  getUserLanguage: () => navigator && navigator.language,
+
+  /**
+   * @param {*} req
+   * @returns {string} userAgent
+   */
+  getUserAgent: () => navigator && navigator.userAgent,
+};
+
+export default USER_INTERFACE;

package/src/utils/logUtil.js

@@ -0,0 +1,51 @@
+const LOG_LEVEL_INFO = 1;
+const LOG_LEVEL_DEBUG = 2;
+const LOG_LEVEL_WARN = 3;
+const LOG_LEVEL_ERROR = 4;
+const DEF_LOG_LEVEL = LOG_LEVEL_ERROR;
+let LOG_LEVEL = DEF_LOG_LEVEL;
+
+const logger = {
+  setLogLevel(logLevel) {
+    switch (logLevel.toUpperCase()) {
+      case 'INFO':
+        LOG_LEVEL = LOG_LEVEL_INFO;
+        break;
+      case 'DEBUG':
+        LOG_LEVEL = LOG_LEVEL_DEBUG;
+        break;
+      case 'WARN':
+        LOG_LEVEL = LOG_LEVEL_WARN;
+        break;
+      default:
+        LOG_LEVEL = DEF_LOG_LEVEL;
+        break;
+    }
+  },
+
+  info(...args) {
+    if (LOG_LEVEL <= LOG_LEVEL_INFO) {
+      console.info(...args);
+    }
+  },
+
+  debug(...args) {
+    if (LOG_LEVEL <= LOG_LEVEL_DEBUG) {
+      console.log(...args);
+    }
+  },
+
+  warn(...args) {
+    if (LOG_LEVEL <= LOG_LEVEL_WARN) {
+      console.warn(...args);
+    }
+  },
+
+  error(...args) {
+    if (LOG_LEVEL <= LOG_LEVEL_ERROR) {
+      console.error(...args);
+    }
+  },
+};
+
+export default logger;

package/src/utils/logger.js

@@ -0,0 +1,106 @@
+const LogLevel = {
+  LOG: {
+    value: 0,
+    method: console.log,
+  },
+  INFO: {
+    value: 1,
+    method: console.info,
+  },
+  DEBUG: {
+    value: 2,
+    method: console.debug,
+  },
+  WARN: {
+    value: 3,
+    method: console.warn,
+  },
+  ERROR: {
+    value: 4,
+    method: console.error,
+  },
+};
+
+class Logger {
+  constructor(scope, level) {
+    this.level = +level || LogLevel.ERROR.value;
+    this.scope = scope || '';
+  }
+
+  setLogLevel(levelStr) {
+    if (levelStr && typeof levelStr === 'string') {
+      const lvlStr = levelStr.toUpperCase();
+      this.level = LogLevel[lvlStr] ? LogLevel[lvlStr].value : this.level;
+    }
+  }
+
+  setScope(scopeVal) {
+    this.scope = scopeVal || this.scope;
+  }
+
+  log(...args) {
+    this.logBase(args, LogLevel.LOG.value);
+  }
+
+  info(...args) {
+    this.logBase(args, LogLevel.INFO.value);
+  }
+
+  debug(...args) {
+    this.logBase(args, LogLevel.DEBUG.value);
+  }
+
+  warn(...args) {
+    this.logBase(args, LogLevel.WARN.value);
+  }
+
+  error(...args) {
+    this.logBase(args, LogLevel.ERROR.value);
+  }
+
+  logBase(args, logLevel) {
+    if (this.level <= logLevel) {
+      const logVal = Object.values(LogLevel).find((val) => val.value === logLevel);
+      logVal.method(...this.getLogData(args));
+    }
+  }
+
+  /**
+   * Formats the console message using `scope`
+   * @param {*} logArgs
+   * @returns updated log arguments
+   */
+  getLogData(logArgs) {
+    if (Array.isArray(logArgs) && logArgs.length > 0) {
+      // prefix SDK identifier
+      let msg = `%c RS SDK`;
+
+      // format the log message using `scope`
+      if (this.scope) {
+        msg = `${msg} - ${this.scope}`;
+      }
+
+      // trim whitespaces
+      const orgMsg = logArgs[0].trim();
+
+      // prepare the final message
+      msg = `${msg} %c ${orgMsg}`;
+
+      const retArgs = [];
+      retArgs.push(msg);
+
+      // add style for the prefix
+      retArgs.push('font-weight: bold; background: black; color: white;');
+
+      // reset the style for the actual message
+      retArgs.push('font-weight: normal;');
+
+      // append rest of the original arguments
+      retArgs.push(...logArgs.slice(1));
+      return retArgs;
+    }
+    return logArgs;
+  }
+}
+
+export default Logger;

package/src/utils/navigator.js

@@ -0,0 +1,32 @@
+const getUserAgent = () => {
+  if (typeof navigator === 'undefined') {
+    return null;
+  }
+
+  let { userAgent } = navigator;
+  const { brave } = navigator;
+
+  // For supporting Brave browser detection,
+  // add "Brave/<version>" to the user agent with the version value from the Chrome component
+  if (brave && Object.getPrototypeOf(brave).isBrave) {
+    // Example:
+    // Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.114 Safari/537.36
+    const matchedArr = userAgent.match(/(chrome)\/([\w.]+)/i);
+
+    if (matchedArr) {
+      userAgent = `${userAgent} Brave/${matchedArr[2]}`;
+    }
+  }
+
+  return userAgent;
+};
+
+const getLanguage = () => {
+  if (typeof navigator === 'undefined') {
+    return null;
+  }
+
+  return navigator.language || navigator.browserLanguage;
+};
+
+export { getUserAgent, getLanguage };

package/src/utils/notifyError.js

@@ -0,0 +1,16 @@
+import { ERROR_REPORTING_SERVICE_GLOBAL_KEY_NAME } from './constants';
+
+/**
+ * This function is to send handled errors to available error reporting client
+ *
+ * @param {Error} error Error instance from handled error
+ */
+const notifyError = (error) => {
+  const errorReportingClient =
+    window.HtEventsGlobals && window.HtEventsGlobals[ERROR_REPORTING_SERVICE_GLOBAL_KEY_NAME];
+  if (errorReportingClient && error instanceof Error) {
+    errorReportingClient.notify(error);
+  }
+};
+
+export { notifyError };

package/src/utils/pageProperties.js

@@ -0,0 +1,74 @@
+/* eslint-disable consistent-return */
+/* eslint-disable camelcase */
+import Storage from './storage';
+
+function getReferrer() {
+  return document.referrer || '$direct';
+}
+
+function getReferringDomain(referrer) {
+  const split = referrer.split('/');
+  if (split.length >= 3) {
+    return split[2];
+  }
+  return '';
+}
+
+function getCanonicalUrl() {
+  const tags = document.getElementsByTagName('link');
+  for (let i = 0; tags[i]; i += 1) {
+    const tag = tags[i];
+    if (tag.getAttribute('rel') === 'canonical') {
+      return tag.getAttribute('href');
+    }
+  }
+}
+
+function getUrl(search) {
+  const canonicalUrl = getCanonicalUrl();
+  let url;
+  if (canonicalUrl) {
+    url = canonicalUrl.includes('?') ? canonicalUrl : canonicalUrl + search;
+  } else {
+    url = window.location.href;
+  }
+  const hashIndex = url.indexOf('#');
+  return hashIndex > -1 ? url.slice(0, hashIndex) : url;
+}
+
+function getDefaultPageProperties() {
+  const canonicalUrl = getCanonicalUrl();
+  let path = window.location.pathname;
+
+  if (canonicalUrl) {
+    try {
+      const urlObj = new URL(canonicalUrl);
+      path = urlObj.pathname;
+    } catch (err) {
+      // Do nothing
+    }
+  }
+
+  const { search, href } = window.location;
+  const { title } = document;
+  const url = getUrl(search);
+  const tab_url = href;
+
+  const referrer = getReferrer();
+  const referring_domain = getReferringDomain(referrer);
+  const initial_referrer = Storage.getInitialReferrer() || '';
+  const initial_referring_domain = Storage.getInitialReferringDomain() || '';
+  return {
+    path,
+    referrer,
+    referring_domain,
+    search,
+    title,
+    url,
+    tab_url,
+    initial_referrer,
+    initial_referring_domain,
+  };
+}
+
+export { getReferrer, getReferringDomain, getDefaultPageProperties };

package/src/utils/screenDetails.js

@@ -0,0 +1,23 @@
+import { RudderScreenInfo } from './RudderInfo';
+
+const getScreenDetails = () => {
+  const screenDetails = new RudderScreenInfo();
+
+  // Depending on environment within which the code is executing, screen
+  // dimensions can be set
+  // User agent and locale can be retrieved only for browser
+  // When execution is in SSR window will be undefined
+  if (typeof window === 'undefined') {
+    return screenDetails;
+  }
+
+  screenDetails.width = window.screen.width;
+  screenDetails.height = window.screen.height;
+  screenDetails.density = window.devicePixelRatio;
+  screenDetails.innerWidth = window.innerWidth;
+  screenDetails.innerHeight = window.innerHeight;
+
+  return screenDetails;
+};
+
+export { getScreenDetails };

package/src/utils/storage/cookie.js

@@ -0,0 +1,93 @@
+import cookie from 'rudder-component-cookie';
+import defaults from '@ndhoule/defaults';
+import topDomain from '@segment/top-domain';
+import * as R from 'ramda';
+import logger from '../logUtil';
+
+/**
+ * An object utility to persist values in cookies
+ */
+class CookieLocal {
+  constructor(options) {
+    this.cOpts = {};
+    this.options(options);
+    this.isSupportAvailable = this.checkSupportAvailability();
+  }
+
+  /**
+   *
+   * @param {*} inOpts
+   */
+  options(inOpts = {}) {
+    if (arguments.length === 0) return this.cOpts;
+
+    let domain = `.${topDomain(window.location.href)}`;
+    if (domain === '.') domain = null;
+
+    // the default maxage and path
+    this.cOpts = defaults(inOpts, {
+      maxage: 31536000000,
+      path: '/',
+      domain,
+      samesite: 'Lax',
+    });
+
+    return this.cOpts;
+  }
+
+  /**
+   *
+   * @param {*} key
+   * @param {*} value
+   */
+  set(key, value) {
+    try {
+      cookie(key, value, R.clone(this.cOpts));
+      return true;
+    } catch (e) {
+      logger.error(e);
+      return false;
+    }
+  }
+
+  /**
+   *
+   * @param {*} key
+   */
+  get(key) {
+    return cookie(key);
+  }
+
+  /**
+   *
+   * @param {*} key
+   */
+  remove(key) {
+    try {
+      cookie(key, null, R.clone(this.cOpts));
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  /**
+   * Function to check cookie support exists or not
+   * @returns boolean
+   */
+  checkSupportAvailability() {
+    const name = 'test_htevents_cookie';
+    this.set(name, true);
+
+    if (this.get(name)) {
+      this.remove(name);
+      return true;
+    }
+    return false;
+  }
+}
+
+// Exporting only the instance
+const Cookie = new CookieLocal({});
+
+export { Cookie };

package/src/utils/storage/index.js

@@ -0,0 +1,3 @@
+import { Storage } from './storage';
+
+export default new Storage();