noibu-react-native 0.0.4 → 0.0.7

package/dist/utils/function.js

@@ -1,178 +1,120 @@
 import DeviceInfo from 'react-native-device-info';
 import { getLocales } from 'react-native-localize';
 import { parseStack } from './stacktrace-parser.js';
-import { MAX_BEACON_PAYLOAD_SIZE, MAX_STRING_LENGTH, REQUIRED_DATA_PROCESSING_URLS, HTTP_DATA_COLLECTION_FLAG_NAME, HTTP_DATA_PAYLOAD_URL_REGEXES_FLAG_NAME, WIN_BLOCKED_SELECTOR_ATT_NAME, PII_EMAIL_PATTERN, PII_REDACTION_REPLACEMENT_STRING, PII_DIGIT_PATTERN, JS_STACK_FRAMES_ATT_NAME, JS_STACK_MESSAGE_ATT_NAME, JS_STACK_FILE_ATT_NAME, JS_STACK_LINE_ATT_NAME, JS_STACK_COL_ATT_NAME, MAX_FRAMES_IN_ARRAY, NOIBUJS_CONFIG, JS_STACK_METHOD_ATT_NAME, DEFAULT_STACK_FRAME_FIELD_VALUE } from '../constants.js';
+import { MAX_STRING_LENGTH, MAX_BEACON_PAYLOAD_SIZE, REQUIRED_DATA_PROCESSING_URLS, PII_EMAIL_PATTERN, PII_REDACTION_REPLACEMENT_STRING, PII_DIGIT_PATTERN, DEFAULT_STACK_FRAME_FIELD_VALUE } from '../constants.js';
 import ClientConfig from '../api/clientConfig.js';
+import { AppNavigationMonitor } from '../monitors/AppNavigationMonitor.js';
 
 /** @module Functions */
-
 /**
  * Returns a stack trace frame with default filed values
  */
 const getDefaultFrame = () => ({
-  [JS_STACK_LINE_ATT_NAME]: DEFAULT_STACK_FRAME_FIELD_VALUE,
-  [JS_STACK_METHOD_ATT_NAME]: DEFAULT_STACK_FRAME_FIELD_VALUE,
-  [JS_STACK_FILE_ATT_NAME]: DEFAULT_STACK_FRAME_FIELD_VALUE,
+    line: DEFAULT_STACK_FRAME_FIELD_VALUE,
+    mname: DEFAULT_STACK_FRAME_FIELD_VALUE,
+    file: DEFAULT_STACK_FRAME_FIELD_VALUE,
 });
-
 /**
- *
  * returns a string that satisfies a max length
  * stringToVerify: string that needs to be verified
  * length :optional, max length that stringToVerify can be
- * @param stringToVerify
- * @param length
- */
-function getMaxSubstringAllowed(
-  stringToVerify,
-  length = MAX_STRING_LENGTH,
-) {
-  if (!stringToVerify) {
-    return stringToVerify;
-  }
-  if (stringToVerify.length < length) return stringToVerify;
-  return stringToVerify.substring(0, length);
-}
-
-/**
- *
- * todo implement navigation
- * getProperGlobalUrl gets the proper global url from the window
- * @returns {string}
  */
-function getProperGlobalUrl() {
-  const globalUrl = new URL('https://localhost');
-  globalUrl.hostname = ClientConfig.getInstance().customerDomain;
-  return getMaxSubstringAllowed(globalUrl.toString());
+function getMaxSubstringAllowed(stringToVerify, length = MAX_STRING_LENGTH) {
+    if (!stringToVerify) {
+        return stringToVerify;
+    }
+    if (stringToVerify.length < length)
+        return stringToVerify;
+    return stringToVerify.substring(0, length);
 }
-
 /**
  * Processes the raw stack frames and creates a readable stack in a safe manner
  * @param {StackFrame[]} rawFrames
  */
 function processFrames(rawFrames) {
-  return rawFrames.map(frame => {
-    const processedFrame = getDefaultFrame();
-
-    if (frame[JS_STACK_LINE_ATT_NAME]) {
-      if (Number.isInteger(frame[JS_STACK_LINE_ATT_NAME])) {
-        processedFrame[JS_STACK_LINE_ATT_NAME] = String(
-          frame[JS_STACK_LINE_ATT_NAME],
-        );
-      }
-    }
-
-    if (
-      frame[JS_STACK_METHOD_ATT_NAME] &&
-      frame[JS_STACK_METHOD_ATT_NAME] !== '<unknown>'
-    ) {
-      processedFrame[JS_STACK_METHOD_ATT_NAME] = String(
-        frame[JS_STACK_METHOD_ATT_NAME],
-      );
-    }
-
-    if (
-      frame[JS_STACK_FILE_ATT_NAME] &&
-      frame[JS_STACK_FILE_ATT_NAME] !== '<unknown>'
-    ) {
-      processedFrame[JS_STACK_FILE_ATT_NAME] = String(
-        frame[JS_STACK_FILE_ATT_NAME],
-      );
-    }
-
-    if (frame[JS_STACK_COL_ATT_NAME]) {
-      if (Number.isInteger(frame[JS_STACK_COL_ATT_NAME])) {
-        processedFrame[JS_STACK_COL_ATT_NAME] = frame[JS_STACK_COL_ATT_NAME];
-      }
-    }
-
-    return processedFrame;
-  });
+    return rawFrames.map(frame => {
+        const processedFrame = getDefaultFrame();
+        if (frame.line) {
+            if (Number.isInteger(frame.line)) {
+                processedFrame.line = String(frame.line);
+            }
+        }
+        if (frame.mname && frame.mname !== '<unknown>') {
+            processedFrame.mname = String(frame.mname);
+        }
+        if (frame.file && frame.file !== '<unknown>') {
+            processedFrame.file = String(frame.file);
+        }
+        if (frame.column) {
+            if (Number.isInteger(frame.column)) {
+                processedFrame.column = frame.column;
+            }
+        }
+        return processedFrame;
+    });
 }
-
 /**
  * Retrieves the javascript stack and message from an error event object
  * @param errObj error to extract stack from
  */
 function getJSStack(errObj) {
-  let frames = [
-    {
-      [JS_STACK_LINE_ATT_NAME]: DEFAULT_STACK_FRAME_FIELD_VALUE,
-      [JS_STACK_METHOD_ATT_NAME]: DEFAULT_STACK_FRAME_FIELD_VALUE,
-      [JS_STACK_FILE_ATT_NAME]: DEFAULT_STACK_FRAME_FIELD_VALUE,
-    },
-  ];
-
-  // if the errObj type is not an object or null
-  // return a default frame
-  if (typeof errObj !== 'object' || !errObj) {
-    return {
-      [JS_STACK_FRAMES_ATT_NAME]: frames,
-      [JS_STACK_MESSAGE_ATT_NAME]: '',
-    };
-  }
-
-  // If there is no stack field present then try to read the single file/line/column values
-  if (!errObj.stack) {
-    if (errObj.fileName && typeof errObj.fileName === 'string') {
-      frames[0][JS_STACK_FILE_ATT_NAME] = errObj.fileName;
-    }
-    if (errObj.lineNumber) {
-      frames[0][JS_STACK_LINE_ATT_NAME] = String(errObj.lineNumber);
-    }
-    if (errObj.columnNumber && Number.isInteger(errObj.columnNumber)) {
-      frames[0][JS_STACK_COL_ATT_NAME] = errObj.columnNumber;
+    let frames = [
+        {
+            line: DEFAULT_STACK_FRAME_FIELD_VALUE,
+            mname: DEFAULT_STACK_FRAME_FIELD_VALUE,
+            file: DEFAULT_STACK_FRAME_FIELD_VALUE,
+        },
+    ];
+    // if the errObj type is not an object or null
+    // return a default frame
+    if (typeof errObj !== 'object' || !errObj) {
+        return {
+            frames,
+            msg: '',
+        };
     }
-  } else {
     frames = processFrames(parseStack(errObj.stack));
-  }
-
-  if (frames.length >= MAX_FRAMES_IN_ARRAY) {
-    frames = frames.slice(0, MAX_FRAMES_IN_ARRAY);
-  }
-
-  const msg = errObj.message ? getMaxSubstringAllowed(errObj.message) : '';
-  return {
-    [JS_STACK_FRAMES_ATT_NAME]: frames,
-    [JS_STACK_MESSAGE_ATT_NAME]: msg,
-  };
+    const msg = errObj.message ? getMaxSubstringAllowed(errObj.message) : '';
+    return {
+        frames,
+        msg,
+    };
 }
-
 /**
- * @param {string} possiblyStacktrace
- * @returns {boolean}
+ * Checks if possiblyStacktrace has any stack frames present
  */
 function isStackTrace(possiblyStacktrace) {
-  try {
-    return parseStack(possiblyStacktrace).length > 0;
-  } catch (e) {
-    return false;
-  }
+    try {
+        // todo disable temporary
+        // return parseStack(possiblyStacktrace).length > 0;
+        return false;
+    }
+    catch (e) {
+        return false;
+    }
 }
-
 /**
- * safely stringifies an object
- * @param jsonObject
+ * Stringify function that is aware of inner circular references and handles them by replacing with {} (empty object)
+ * taken from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Cyclic_object_value
  */
 function stringifyJSON(jsonObject) {
-  // prototype.js version < 1.7 defines a toJSON on the prototype of
-  // arrays. This is wrong and they have fixed it since, but some old websites
-  // still use that lib and it messes up our the expected serilization on metroplex's
-  // side.
-  if (Array.prototype.toJSON) {
-    // this piece of code is safe since js guarentees that only one thing is running
-    // at once, therefore the prototype will be changed only while this function is executing
-    const oldToJSON = Array.prototype.toJSON;
-    delete Array.prototype.toJSON;
-    const jsonString = JSON.stringify(jsonObject);
-    // we want to re-enable the existing prototype behaviour
-    // eslint-disable-next-line no-extend-native
-    Array.prototype.toJSON = oldToJSON;
-    return jsonString;
-  }
-  return JSON.stringify(jsonObject);
+    const ancestors = [];
+    return JSON.stringify(jsonObject, function (k, v) {
+        if (typeof v !== 'object' || v === null) {
+            return v;
+        }
+        // `this` is the object that value is contained in,
+        // i.e., its direct parent.
+        while (ancestors.length > 0 && ancestors[ancestors.length - 1] !== this) {
+            ancestors.pop();
+        }
+        if (ancestors.includes(v)) {
+            return {};
+        }
+        ancestors.push(v);
+        return v;
+    });
 }
-
 /**
  * Wrapper for a request, since we have to do some special handling
  * @param method
@@ -182,244 +124,192 @@ function stringifyJSON(jsonObject) {
  * @param timeout
  * @param sendAndForget
  */
-async function makeRequest(
-  method,
-  url,
-  data,
-  headers,
-  timeout,
-  sendAndForget,
-) {
-  const ua = Object.keys(headers).findLast(
-    k => k.toLowerCase() === 'user-agent',
-  );
-  const headersWithUa = { ...headers };
-  if (!headers[ua]) {
-    headersWithUa['User-Agent'] = await getUserAgent();
-  }
-
-  // a send-and-forget request is made by using the beacon API (fetch + keepalive)
-  if (sendAndForget) {
-    const stringData = stringifyJSON(data);
-    const currentPayloadSize = new Blob([stringData]).size;
-    // if we have a large object or fetch is not available, we skip sending the message
-    if (!global.fetch || currentPayloadSize > MAX_BEACON_PAYLOAD_SIZE) {
-      return new Promise(resolve => {
-        resolve();
-      });
+async function makeRequest(method, url, data, headers, timeout, sendAndForget) {
+    const ua = Object.keys(headers).findLast(k => k.toLowerCase() === 'user-agent');
+    const headersWithUa = { ...headers };
+    if (!headers[ua]) {
+        headersWithUa['User-Agent'] = await getUserAgent();
     }
-
-    return fetch(url, {
-      method: 'POST',
-      headers: headersWithUa,
-      body: stringifyJSON(data),
-      // keep alive outlives the current page, its the same as beacon
-      keepalive: true,
-    });
-  }
-
-  return new Promise((resolve, reject) => {
-    const xhr = new global.XMLHttpRequest();
-    xhr.open(method, url);
-    xhr.timeout = timeout;
-    Object.keys(headersWithUa).forEach(header => {
-      xhr.setRequestHeader(header, headers[header]);
-    });
-
-    xhr.onload = () => {
-      if (xhr.status >= 200 && xhr.status < 300) {
-        resolve(xhr.response);
-      } else {
-        reject(new Error(`Custom Request failed: ${xhr.statusText}`));
-      }
-    };
-    xhr.onerror = () => {
-      reject(new Error(`Custom Request failed: ${xhr.statusText}`));
-    };
-    if (data) {
-      xhr.send(stringifyJSON(data));
-    } else {
-      xhr.send();
+    // a send-and-forget request is made by using the beacon API (fetch + keepalive)
+    if (sendAndForget) {
+        const stringData = stringifyJSON(data);
+        const currentPayloadSize = new Blob([stringData]).size;
+        // if we have a large object or fetch is not available, we skip sending the message
+        if (currentPayloadSize > MAX_BEACON_PAYLOAD_SIZE) {
+            return Promise.resolve();
+        }
+        return fetch(url, {
+            method: 'POST',
+            headers: headersWithUa,
+            body: stringifyJSON(data),
+            // keep alive outlives the current page, its the same as beacon
+            keepalive: true,
+        });
     }
-  });
-}
-
-/** determines if we have received the block selector */
-function checkBlockedSelectorExistence() {
-  const noibuConfig = NOIBUJS_CONFIG();
-  return (
-    noibuConfig[WIN_BLOCKED_SELECTOR_ATT_NAME] &&
-    Array.isArray(noibuConfig[WIN_BLOCKED_SELECTOR_ATT_NAME])
-  );
+    return new Promise((resolve, reject) => {
+        const xhr = new XMLHttpRequest();
+        xhr.open(method, url);
+        xhr.timeout = timeout;
+        Object.keys(headersWithUa).forEach(header => {
+            xhr.setRequestHeader(header, headers[header]);
+        });
+        xhr.onload = () => {
+            if (xhr.status >= 200 && xhr.status < 300) {
+                resolve(xhr.response);
+            }
+            else {
+                reject(new Error(`Custom Request failed: ${xhr.statusText}`));
+            }
+        };
+        xhr.onerror = () => {
+            reject(new Error(`Custom Request failed: ${xhr.statusText}`));
+        };
+        if (data) {
+            xhr.send(stringifyJSON(data));
+        }
+        else {
+            xhr.send();
+        }
+    });
 }
-
 /** checks if  http data collection is enabled */
 function checkHttpDataCollectionEnabled() {
-  const noibuConfig = NOIBUJS_CONFIG();
-  // Just a boolean, so safe to return truthiness. If undefined, will return false.
-  return !!noibuConfig[HTTP_DATA_COLLECTION_FLAG_NAME];
-}
-
-/** determines if we have received the http allowed urls */
-function checkHttpPayloadAllowedURLsExistence() {
-  const noibuConfig = NOIBUJS_CONFIG();
-  return (
-    noibuConfig[HTTP_DATA_PAYLOAD_URL_REGEXES_FLAG_NAME] &&
-    Array.isArray(noibuConfig[HTTP_DATA_PAYLOAD_URL_REGEXES_FLAG_NAME])
-  );
+    const noibuConfig = ClientConfig.getInstance();
+    // Just a boolean, so safe to return truthiness. If undefined, will return false.
+    return !!noibuConfig.enableHttpDataCollection;
 }
-
 /** gets http data payload allowed URLs */
 function getHttpPayloadAllowedURLs() {
-  const noibuConfig = NOIBUJS_CONFIG();
-  // return the allowed list or an empty list
-  if (checkHttpPayloadAllowedURLsExistence()) {
-    return noibuConfig[HTTP_DATA_PAYLOAD_URL_REGEXES_FLAG_NAME];
-  }
-  return [];
+    const noibuConfig = ClientConfig.getInstance();
+    // return the allowed list or an empty list
+    if (noibuConfig.listOfUrlsToCollectHttpDataFrom &&
+        Array.isArray(noibuConfig.listOfUrlsToCollectHttpDataFrom)) {
+        return noibuConfig.listOfUrlsToCollectHttpDataFrom;
+    }
+    return [];
 }
 /**
- * Gets all the blocked css classes to prevent those elements from being recorded
+ * Gets selectors to prevent those elements from being recorded
  */
-function getBlockedCSSForCurrentDomain() {
-  const noibuConfig = NOIBUJS_CONFIG();
-  const blockedCSS = ['noibu-blocked'];
-  if (checkBlockedSelectorExistence()) {
-    noibuConfig[WIN_BLOCKED_SELECTOR_ATT_NAME].forEach(sel => {
-      // this means that we are looking at a class
-      if (sel.startsWith('.') && sel.length > 0) {
-        // selecting everything after and including the element at index 1
-        blockedCSS.push(sel.substring(1));
-      }
-    });
-  }
-  return blockedCSS;
+function getBlockedElements() {
+    const selectors = ClientConfig.getInstance().blockedElements;
+    const blockedElements = ['noibu-blocked'];
+    if (selectors && Array.isArray(selectors)) {
+        blockedElements.push(...selectors);
+    }
+    return blockedElements;
 }
 /**
  * makes sure the url sent is a valid URL
- * @param  {} string url to be validated
  */
-function isValidURL(string) {
-  try {
-    const _ = new URL(string);
-    return true;
-  } catch (_) {
-    return false;
-  }
+function isValidURL(str) {
+    try {
+        return !!new URL(str);
+    }
+    catch (_) {
+        return false;
+    }
 }
-
 let userAgentCache = '';
-
 /**
  * Because of the nature of user agent in react native, we have to make this async.
  * But I promise, this is really fast, since we memoize the result for the whole session :)
  * @returns {Promise<string>}
  */
 async function getUserAgent() {
-  if (userAgentCache) {
+    if (userAgentCache) {
+        return userAgentCache;
+    }
+    try {
+        userAgentCache = await DeviceInfo.getUserAgent();
+    }
+    catch (e) {
+        userAgentCache = '';
+    }
     return userAgentCache;
-  }
-  userAgentCache = await DeviceInfo.getUserAgent();
-  return userAgentCache;
 }
-
 /**
  * isInvalidURLConfig will verify that Collect is being initializes with
  * the correct env vars.
- * @param  {Noibu.UrlConfig} urlConfig
  */
-function isInvalidURLConfig(urlConfig) {
-  for (let i = 0; i < REQUIRED_DATA_PROCESSING_URLS.length; i += 1) {
-    const u = REQUIRED_DATA_PROCESSING_URLS[i];
-    if (!urlConfig[u]) {
-      return true;
+function isInvalidURLConfig(urls) {
+    for (let i = 0; i < REQUIRED_DATA_PROCESSING_URLS.length; i += 1) {
+        const u = REQUIRED_DATA_PROCESSING_URLS[i];
+        if (!urls[u]) {
+            return true;
+        }
     }
-  }
-
-  return false;
+    return false;
 }
-
 /**
  * isNoibuJSAlreadyLoaded will verify if there are already other
  * copies of NoibuJS runnung
  */
 function isNoibuJSAlreadyLoaded() {
-  // check if the global variable exists and its value
-  const loaded = window.noibuJSLoaded !== undefined;
-  // set the variable so future copies of the script
-  // will know this instance is running
-  window.noibuJSLoaded = true;
-  return loaded;
+    // check if the global variable exists and its value
+    const loaded = window.noibuJSLoaded !== undefined;
+    // set the variable so future copies of the script
+    // will know this instance is running
+    window.noibuJSLoaded = true;
+    return loaded;
 }
-
-/** asString will create a string out of anything passed to it.
- * @param  {} obj
+/**
+ * asString will create a string out of anything passed to it.
  */
 function asString(obj) {
-  if (!obj) {
-    return '';
-  }
-  // we've seen the url be an object in some cases
-  // we would still like to send those to our backend in the case
-  // that this is an issue and needs to be queried
-  if (typeof obj === 'object') {
-    return stringifyJSON(obj);
-  }
-
-  return String(obj);
+    if (!obj) {
+        return '';
+    }
+    // we've seen the url be an object in some cases
+    // we would still like to send those to our backend in the case
+    // that this is an issue and needs to be queried
+    if (typeof obj === 'object') {
+        return stringifyJSON(obj);
+    }
+    return String(obj);
 }
-
-/** masks textual content if it ressembles something sensitive
- * @param  {} text
+/**
+ * masks textual content if it ressembles something sensitive
  */
 function maskTextInput(text) {
-  // if it has an email or digit(s), we mask the text
-  return text
-    .replace(PII_EMAIL_PATTERN, PII_REDACTION_REPLACEMENT_STRING)
-    .replace(PII_DIGIT_PATTERN, '*');
+    // if it has an email or digit(s), we mask the text
+    return text
+        .replace(PII_EMAIL_PATTERN, PII_REDACTION_REPLACEMENT_STRING)
+        .replace(PII_DIGIT_PATTERN, '*');
 }
-
-/** gets the onURL of a string, defaulting to the location of the webpage
- * @param  {} realOnURL
+/**
+ * gets the onURL of a string, defaulting to the location of the webpage
  */
 function getOnURL(realOnURL) {
-  let onURL = getProperGlobalUrl();
-
-  if (realOnURL && realOnURL.trim() !== '' && realOnURL !== 'undefined') {
-    onURL = asString(getMaxSubstringAllowed(realOnURL));
-  }
-
-  return onURL;
+    if (realOnURL && realOnURL.trim() !== '' && realOnURL !== 'undefined') {
+        return asString(getMaxSubstringAllowed(realOnURL));
+    }
+    return AppNavigationMonitor.getInstance().globalUrl;
 }
-
 /** gets the user language from the browser */
 function getUserLanguage() {
-  const locales = getLocales();
-  if (!locales.length) {
-    return null;
-  }
-  const lang = locales[0].languageCode;
-
-  if (lang === '' || !lang) {
-    return null;
-  }
-
-  return lang.toLowerCase();
+    const locales = getLocales();
+    if (!locales.length) {
+        return null;
+    }
+    const lang = locales[0].languageCode;
+    if (lang === '' || !lang) {
+        return null;
+    }
+    return lang.toLowerCase();
 }
-
 /**
  * Checks if the provided object is an instance of the specified type.
  * It's safer than `instanceof` operator as it handles cases
  * where type is not actually a type but an object.
- * @param {any} instance
- * @param {any} type
  */
 function isInstanceOf(instance, type) {
-  try {
-    return typeof type === 'function' && instance instanceof type;
-  } catch (e) {
-    return false;
-  }
+    try {
+        return typeof type === 'function' && instance instanceof type;
+    }
+    catch (e) {
+        return false;
+    }
 }
 
-export { asString, checkHttpDataCollectionEnabled, getBlockedCSSForCurrentDomain, getHttpPayloadAllowedURLs, getJSStack, getMaxSubstringAllowed, getOnURL, getProperGlobalUrl, getUserAgent, getUserLanguage, isInstanceOf, isInvalidURLConfig, isNoibuJSAlreadyLoaded, isStackTrace, isValidURL, makeRequest, maskTextInput, processFrames, stringifyJSON };
+export { asString, checkHttpDataCollectionEnabled, getBlockedElements, getHttpPayloadAllowedURLs, getJSStack, getMaxSubstringAllowed, getOnURL, getUserAgent, getUserLanguage, isInstanceOf, isInvalidURLConfig, isNoibuJSAlreadyLoaded, isStackTrace, isValidURL, makeRequest, maskTextInput, processFrames, stringifyJSON };

package/dist/utils/stacktrace-parser.d.ts

@@ -1,9 +1,7 @@
-import { JS_STACK_COL_ATT_NAME, JS_STACK_FILE_ATT_NAME, JS_STACK_LINE_ATT_NAME, JS_STACK_METHOD_ATT_NAME } from '../constants';
-declare interface StackFrame {
-    [JS_STACK_FILE_ATT_NAME]: string;
-    [JS_STACK_LINE_ATT_NAME]?: number;
-    [JS_STACK_COL_ATT_NAME]?: number;
-    [JS_STACK_METHOD_ATT_NAME]: string;
+export declare interface RawStackFrame {
+    file: string;
+    line?: number;
+    column?: number;
+    mname: string;
 }
-export declare function parseStack(stackString: string): StackFrame[];
-export {};
+export declare function parseStack(stackString: string): RawStackFrame[];