noibu-react-native 0.0.1

package/dist/react/ErrorBoundary.js

@@ -0,0 +1,102 @@
+import * as React from 'react';
+import uuid from 'react-native-uuid';
+import InputManager from '../api/inputManager.js';
+
+// initial state variables
+const INITIAL_STATE = {
+    componentStack: null,
+    error: null,
+    eventId: null,
+};
+/**
+ * @description A ErrorBoundary component that logs errors to Noibu. Requires React >= 16.
+ * @extends {Component<ErrorBoundaryProps, ErrorBoundaryState>}
+ */
+class ErrorBoundary extends React.Component {
+    state = INITIAL_STATE;
+    /**
+     * Lifecycle hook on mount
+     * @returns void
+     */
+    componentDidMount() {
+        const { onMount } = this.props;
+        if (onMount) {
+            onMount();
+        }
+    }
+    /**
+     *
+     * Handler for all errors that happen in a wrapped component
+     * @param  {Error&{cause?:Error}} error
+     * @param  {React.ErrorInfo} {componentStack}
+     * @returns void
+     */
+    componentDidCatch(error, { componentStack }) {
+        const { onError } = this.props;
+        InputManager.getInstance()._addErrorFromJSSdk(error, 'ReactError');
+        const eventId = uuid.v4();
+        if (onError) {
+            onError(error, componentStack, eventId);
+        }
+        // componentDidCatch is used over getDerivedStateFromError
+        // so that componentStack is accessible through state.
+        this.setState({ error, componentStack, eventId });
+    }
+    /**
+     *  * Lifecycle hook on unmount
+     * @returns void
+     */
+    componentWillUnmount() {
+        const { error, componentStack, eventId } = this.state;
+        const { onUnmount } = this.props;
+        if (onUnmount) {
+            onUnmount(error, componentStack, eventId);
+        }
+    }
+    /**
+     * Callback from fallback to reset the error boundary
+     * @param  {} =>void=(
+     */
+    resetErrorBoundary = () => {
+        const { onReset } = this.props;
+        const { error, componentStack, eventId } = this.state;
+        if (onReset) {
+            onReset(error, componentStack, eventId);
+        }
+        this.setState(INITIAL_STATE);
+    };
+    /**
+     *
+     * Renders the fallback ui
+     * @returns {React.ReactNode}
+     */
+    render() {
+        const { fallback, children } = this.props;
+        const { error, componentStack, eventId } = this.state;
+        if (error) {
+            let element;
+            if (typeof fallback === 'function') {
+                element = fallback({
+                    error,
+                    componentStack,
+                    resetError: this.resetErrorBoundary,
+                    eventId,
+                });
+            }
+            else {
+                element = fallback;
+            }
+            if (React.isValidElement(element)) {
+                return element;
+            }
+            // Fail gracefully if no fallback provided or is not valid
+            return null;
+        }
+        if (typeof children === 'function') {
+            return children();
+        }
+        return children;
+    }
+}
+
+export { ErrorBoundary };

package/dist/storage/localStorageProvider.js

@@ -0,0 +1,23 @@
+import StorageProvider from './storageProvider.js';
+
+/**
+ * Local storage provider implementation
+ */
+class LocalStorageProvider extends StorageProvider {
+  /**
+   * Creates new instance
+   */
+  constructor() {
+    super(window.localStorage);
+  }
+
+  /**
+   * Checks if storage is available
+   * @returns {Object}
+   */
+  static isAvailable() {
+    return StorageProvider.isAvailable(() => window.localStorage);
+  }
+}
+
+export { LocalStorageProvider as default };

package/dist/storage/rnStorageProvider.js

@@ -0,0 +1,62 @@
+import StorageProvider from './storageProvider.js';
+
+// eslint-disable-next-line max-classes-per-file
+
+/**
+ * React native storage implementation: temporary
+ */
+class RNStorageTmp {
+  /** */
+  constructor() {
+    this._map = new Map();
+  }
+
+  /**
+   * @param key
+   * @returns {string}
+   */
+  getItem(key) {
+    return this._map.get(key);
+  }
+
+  /**
+   * @param key
+   * @param value
+   * @returns {Map<string, string>}
+   */
+  setItem(key, value) {
+    return this._map.set(key, value);
+  }
+
+  /**
+   * @param key
+   * @returns {boolean}
+   */
+  removeItem(key) {
+    return this._map.delete(key);
+  }
+}
+
+/**
+ * React native storage provider implementation
+ */
+class RNStorageProvider extends StorageProvider {
+  static storage = new RNStorageTmp();
+
+  /**
+   * Creates new instance
+   */
+  constructor() {
+    super(RNStorageProvider.storage);
+  }
+
+  /**
+   * Checks if storage is available
+   * @returns {Object}
+   */
+  static isAvailable() {
+    return StorageProvider.isAvailable(() => RNStorageProvider.storage);
+  }
+}
+
+export { RNStorageProvider as default };

package/dist/storage/sessionStorageProvider.js

@@ -0,0 +1,23 @@
+import StorageProvider from './storageProvider.js';
+
+/**
+ * Session storage provider implementation
+ */
+class SessionStorageProvider extends StorageProvider {
+  /**
+   * Creates new instance
+   */
+  constructor() {
+    super(window.sessionStorage);
+  }
+
+  /**
+   * Checks if storage is available
+   * @returns {Object}
+   */
+  static isAvailable() {
+    return StorageProvider.isAvailable(() => window.sessionStorage);
+  }
+}
+
+export { SessionStorageProvider as default };

package/dist/storage/storage.js

@@ -0,0 +1,119 @@
+import LocalStorageProvider from './localStorageProvider.js';
+import SessionStorageProvider from './sessionStorageProvider.js';
+import RNStorageProvider from './rnStorageProvider.js';
+
+/**
+ * Encapsulates storage api
+ */
+class Storage {
+  /**
+   * Creates new instance assessing available options
+   */
+  constructor() {
+    const localStorageAvailability = LocalStorageProvider.isAvailable();
+    const sessionStorageAvailability = SessionStorageProvider.isAvailable();
+    const rnStorageAvailability = RNStorageProvider.isAvailable();
+    this._isLocalStorageAvailable = localStorageAvailability.result;
+    this._isSessionStorageAvailable = sessionStorageAvailability.result;
+    this._isRNStorageAvailable = rnStorageAvailability.result;
+    this._localStorageError = localStorageAvailability.error;
+    this._sessionStorageError = sessionStorageAvailability.error;
+    this._rnStorageError = rnStorageAvailability.error;
+    this._provider = null;
+    this._type = 'unavailable';
+
+    if (this._isLocalStorageAvailable) {
+      this._provider = new LocalStorageProvider();
+      this._type = 'LocalStorage';
+    } else if (this._isSessionStorageAvailable) {
+      this._provider = new SessionStorageProvider();
+      this._type = 'SessionStorage';
+    } else if (this._isRNStorageAvailable) {
+      console.log('_isRNStorageAvailable');
+      this._provider = new RNStorageProvider();
+      this._type = 'RNStorage';
+    }
+  }
+
+  /**
+   * Singleton
+   * @returns {Storage}
+   */
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new Storage();
+    }
+    return this._instance;
+  }
+
+  /**
+   * Checks if storage is available
+   * @returns {Boolean}
+   */
+  isAvailable() {
+    return this._provider != null;
+  }
+
+  /**
+   * Loads value from storage
+   * @param {String} key
+   * @returns {String}
+   */
+  load(key) {
+    if (this.isAvailable()) {
+      return this._provider.load(key);
+    }
+    return null;
+  }
+
+  /**
+   * Saves value to storage
+   * @param {String} key
+   * @param {String} value
+   */
+  save(key, value) {
+    if (this.isAvailable()) {
+      this._provider.save(key, value);
+    }
+  }
+
+  /**
+   * Removes value from storage
+   * @param {String} key
+   */
+  remove(key) {
+    if (this.isAvailable()) {
+      this._provider.remove(key);
+    }
+  }
+
+  /**
+   * Calculates used scape
+   * @returns {Number}
+   */
+  calculateUsedSize() {
+    if (this.isAvailable()) {
+      return this._provider.calculateUsedSize();
+    }
+    return 0;
+  }
+
+  /**
+   * Returns string indicating current provider type
+   * and availability for other storage types
+   * @returns {String}
+   */
+  getDiagnoseInfo() {
+    return (
+      `storage provider: ${this._type} ` +
+      `(localStorage available: ${this._isLocalStorageAvailable}, ` +
+      `error: ${this._localStorageError}) ` +
+      `(sessionStorage available: ${this._isSessionStorageAvailable}, ` +
+      `error: ${this._sessionStorageError})` +
+      `(rnStorage available: ${this._isRNStorageAvailable}, ` +
+      `error: ${this._rnStorageError})`
+    );
+  }
+}
+
+export { Storage as default };

package/dist/storage/storageProvider.js

@@ -0,0 +1,83 @@
+import { NOIBU_LOCAL_STORAGE_TEST_KEY } from '../constants.js';
+
+/**
+ * Base implementation for LocalStorage and SessionStorage
+ */
+class StorageProvider {
+  /**
+   * Creates new instance based on provided provider type
+   * @param {WindowLocalStorage|WindowSessionStorage|RNStorageTmp} provider
+   */
+  constructor(provider) {
+    this._provider = provider;
+  }
+
+  /**
+   * Checks if provider is available
+   * @param {Function} function that returns storage instance
+   * @return {Object} { result: true|false, error: null|Error }
+   */
+  static isAvailable(resolver) {
+    let result = true;
+    let error = null;
+    try {
+      // access to localStorage/sessionStorage may throw an error
+      // so use function to resolve it wrapped with try/catch
+      const provider = resolver();
+      console.log({ provider, providerset: provider.setItem });
+      provider.setItem(NOIBU_LOCAL_STORAGE_TEST_KEY, 0);
+      provider.removeItem(NOIBU_LOCAL_STORAGE_TEST_KEY);
+    } catch (e) {
+      result = false;
+      error = e;
+    }
+    return { result, error };
+  }
+
+  /**
+   * Loads value from storage
+   * @param {String} key
+   * @returns {String}
+   */
+  load(key) {
+    return this._provider.getItem(key);
+  }
+
+  /**
+   * Saves value to storage
+   * @param {String} key
+   * @param {String} value
+   */
+  save(key, value) {
+    this._provider.setItem(key, value);
+  }
+
+  /**
+   * Removes value from storage
+   * @param {String} key
+   */
+  remove(key) {
+    this._provider.removeItem(key);
+  }
+
+  /**
+   * Calculates used scape
+   * @returns {Number}
+   */
+  calculateUsedSize() {
+    let size = 0;
+    for (let i = 0; i < this._provider.length; i++) {
+      const key = this._provider.key(i);
+      if (key) {
+        size += key.length;
+        const value = this._provider.getItem(key);
+        if (value) {
+          size += value.length;
+        }
+      }
+    }
+    return size;
+  }
+}
+
+export { StorageProvider as default };

package/dist/utils/date.js

@@ -0,0 +1,62 @@
+import ClientConfig from '../api/clientConfig.js';
+import { SEVERITY_ERROR } from '../constants.js';
+
+/** @module Date */
+
+/** Checks to see if the necessary Date functions that we use have been overwritten */
+function isDateOverwritten() {
+  // Check to see if Date.now() exists
+  if (!('now' in Date)) {
+    return true;
+  }
+
+  // Check to ensure that Date.now() returns a number
+  if (typeof Date.now() !== 'number') {
+    return true;
+  }
+
+  // Check to see if new Date().toISOString() exists
+  if (!('toISOString' in new Date())) {
+    return true;
+  }
+
+  // Check to ensure new Date().toISOString() returns a string
+  if (typeof new Date().toISOString() !== 'string') {
+    return true;
+  }
+
+  // If none of the above checks return true, we assume that the Date function
+  // has not been overwritten
+  return false;
+}
+
+/** Timestamp wrapper to properly handle timestamps
+ * @param  {} timestamp
+ */
+function timestampWrapper(timestamp) {
+  // If the Date object has been overwritten and the timestamp is not a number,
+  // we use the valueOf property to try to retrieve the actual timestamp.
+  // If valueOf is not available, we disable client and log the error.
+  if (typeof timestamp !== 'number' && isDateOverwritten()) {
+    if (
+      // eslint-disable-next-line no-prototype-builtins
+      Date.prototype.hasOwnProperty('valueOf') &&
+      typeof timestamp.valueOf === 'function' &&
+      typeof timestamp.valueOf() === 'number'
+    ) {
+      return timestamp.valueOf();
+    }
+
+    ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(
+      `The date object has been overwritten and can't be processed properly.
+      Client has been disabled.`,
+      true,
+      SEVERITY_ERROR,
+      true,
+    );
+  }
+
+  return timestamp;
+}
+
+export { isDateOverwritten, timestampWrapper };

package/dist/utils/eventlistener.js

@@ -0,0 +1,67 @@
+import { SEVERITY_ERROR } from '../constants.js';
+import ClientConfig from '../api/clientConfig.js';
+
+/** addSafeEventListener will add an event listener for the specified event
+ * but will catch and log any errors encountered
+ * @param  {} object to attach the listener to
+ * @param  {} event to listen to
+ * @param  {} callback function to call
+ * @param  {} capture additional arguments
+ */
+function addSafeEventListener(object, event, callback, capture) {
+  if (!object || !event || !callback) {
+    // nothing to do if these don't exist
+    return;
+  }
+
+  /** safeCallback will catch and log any errors encountered on the callback
+   * @param  {} eventReceived for the callback
+   */
+  const safeCallback = eventReceived => {
+    try {
+      callback(eventReceived);
+    } catch (e) {
+      ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(
+        `addEventListener callback error: ${e.message}`,
+        false,
+        SEVERITY_ERROR,
+      );
+    }
+  };
+
+  /**
+   * tries to add an event listener to a Proxy object
+   */
+  const tryAddEventListenerForProxy = () => {
+    if (!Reflect) {
+      return false;
+    }
+
+    try {
+      const addEventListener =
+        Reflect.get(object, 'addEventListener') || (() => {});
+      addEventListener(event, safeCallback, capture);
+    } catch (e) {
+      return false;
+    }
+
+    return true;
+  };
+
+  try {
+    object.addEventListener(event, safeCallback, capture);
+  } catch (e) {
+    if (e instanceof TypeError) {
+      if (tryAddEventListenerForProxy()) {
+        return;
+      }
+    }
+    ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(
+      `addEventListener error: ${e.message}`,
+      false,
+      SEVERITY_ERROR,
+    );
+  }
+}
+
+export { addSafeEventListener };