noibu-react-native 0.0.1 → 0.0.3

package/dist/pageVisit/pageVisit.js

@@ -36,7 +36,9 @@ class PageVisit {
     }
   }
 
-  /** gets the singleton instance */
+  /** gets the singleton instance
+   * @returns {PageVisit}
+   */
   static getInstance() {
     if (!this.instance) {
       throw new Error('Pagevisit was never configured');

package/dist/pageVisit/pageVisitEventError/blacklistedDomains.js

@@ -0,0 +1,9 @@
+var blacklisedDomains = {
+  'input.noibu.com': true,
+  'input.staging.noibu.com': true,
+  'vf.noibu.com': true,
+  'vf.staging.noibu.com': true,
+  'cdn.noibu.com': true,
+};
+
+export { blacklisedDomains as default };

package/dist/pageVisit/pageVisitEventError/pageVisitEventError.js

@@ -1,5 +1,6 @@
-import { isValidURL, getOnURL, getJSStack, stringifyJSON, getMaxSubstringAllowed } from '../../utils/function.js';
+import { isValidURL, getOnURL, getProperGlobalUrl, getJSStack, stringifyJSON, getMaxSubstringAllowed } from '../../utils/function.js';
 import { EVENT_ERROR_TYPE, URL_ATT_NAME, ERROR_EVENT_TYPE, ERROR_EVENT_ERROR_TYPE, CUSTOM_ERROR_EVENT_TYPE, ERROR_EVENT_UNHANDLED_REJECTION_TYPE, ERROR_LOG_EVENT_ERROR_TYPE, FETCH_EXCEPTION_ERROR_TYPE, WRAPPED_EXCEPTION_ERROR_TYPE, GQL_ERROR_TYPE, RESPONSE_ERROR_TYPE, XML_HTTP_REQUEST_ERROR_TYPE, ERROR_SOURCE_ATT_NAME, TYPE_ATT_NAME, JS_EVENT_TYPE, JS_ERROR_ATT_NAME, JS_STACK_FRAMES_ATT_NAME, JS_STACK_FILE_ATT_NAME, JS_STACK_METHOD_ATT_NAME, SEVERITY_ERROR, JS_STACK_MESSAGE_ATT_NAME, HTTP_EVENT_TYPE, NOIBU_INPUT_URLS, HTTP_CODE_ATT_NAME, PV_SEQ_ATT_NAME, GQL_EVENT_TYPE, GQL_ERROR_ATT_NAME } from '../../constants.js';
+import blacklisedDomains from './blacklistedDomains.js';
 import ClientConfig from '../../api/clientConfig.js';
 import { InputMonitor } from '../../monitors/inputMonitor.js';
 import StoredMetrics from '../../api/storedMetrics.js';
@@ -68,7 +69,7 @@ function getPVErrorFromXMLHttpRequest(errPayload, httpDataSeqNum) {
  */
 function getPVErrorFromErrorEvent(errPayload) {
   return {
-    [URL_ATT_NAME]: getOnURL(errPayload.filename || 'http://localhost'),
+    [URL_ATT_NAME]: getOnURL(errPayload.filename || getProperGlobalUrl()), // todo implement navigation
     [TYPE_ATT_NAME]: JS_EVENT_TYPE,
     [JS_ERROR_ATT_NAME]: getJSStack(errPayload.error),
   };
@@ -80,9 +81,7 @@ function getPVErrorFromErrorEvent(errPayload) {
 function getPVErrorFromErrorLog(errPayload) {
   return {
     // default to window url
-    [URL_ATT_NAME]: getOnURL(
-      (window.location && window.location.href) || 'http://localhost',
-    ),
+    [URL_ATT_NAME]: getOnURL(getProperGlobalUrl()), // todo should be current navigation
     [TYPE_ATT_NAME]: JS_EVENT_TYPE,
     [JS_ERROR_ATT_NAME]: getJSStack(errPayload),
   };
@@ -270,7 +269,7 @@ function isCollectError(pvError) {
 /** Saves the error to the ErrorQueue
  * @param  {} type
  * @param  {} payload
- * @param  {} httpDataSeqNum
+ * @param  {} [httpDataSeqNum]
  */
 function saveErrorToPagevisit(type, payload, httpDataSeqNum) {
   // We do not want to process errors events as errors (yet)
@@ -288,16 +287,12 @@ function saveErrorToPagevisit(type, payload, httpDataSeqNum) {
 
   // We need valid URLs in order to check their blacklist status
   if (isValidURL(currErrURL)) {
-    new URL(currErrURL);
+    const urlOb = new URL(currErrURL);
 
-    // if the domain is blacklisted or the protocol is not http(s)
-    // we drop the error
-    /* if ( // todo we don't support hostname on react native yet
-      urlOb.hostname in blacklisedDomains ||
-      !urlOb.protocol.startsWith('http')
-    ) {
+    // if the domain is blacklisted we drop the error
+    if (urlOb.hostname in blacklisedDomains) {
       return;
-    } */
+    }
   }
 
   if (isCollectError(pvError)) {

package/dist/pageVisit/pageVisitEventHTTP/pageVisitEventHTTP.js

@@ -1,11 +1,10 @@
-import { getMaxSubstringAllowed, asString, getProperGlobalUrl } from '../../utils/function.js';
+import { getMaxSubstringAllowed, asString } from '../../utils/function.js';
 import { timestampWrapper } from '../../utils/date.js';
 import { InputMonitor } from '../../monitors/inputMonitor.js';
-import { HTTP_METHOD_ATT_NAME, MAX_HTTP_DATA_EVENT_COUNT, PV_SEQ_ATT_NAME, HTTP_DATA_METROPLEX_TYPE, NOIBUJS_CONFIG, HTTP_DATA_PAYLOAD_URL_REGEXES_FLAG_NAME, SEVERITY_ERROR, HTTP_EVENT_TYPE, PAGE_VISIT_HTTP_DATA_ATT_NAME } from '../../constants.js';
+import { HTTP_METHOD_ATT_NAME, MAX_HTTP_DATA_EVENT_COUNT, PV_SEQ_ATT_NAME, HTTP_DATA_METROPLEX_TYPE, HTTP_EVENT_TYPE, PAGE_VISIT_HTTP_DATA_ATT_NAME } from '../../constants.js';
 import { PageVisit } from '../pageVisit.js';
 import StoredMetrics from '../../api/storedMetrics.js';
 import MetroplexSocket from '../../api/metroplexSocket.js';
-import ClientConfig from '../../api/clientConfig.js';
 
 /** @module PageVisitEventHTTP */
 
@@ -79,16 +78,6 @@ class PageVisitEventHTTP {
           HTTP_DATA_METROPLEX_TYPE,
           metroplexMsg,
         );
-
-        if (getProperGlobalUrl().includes('checkout.mec.ca')) {
-          ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(
-            `Sending PVH to Metro: ${JSON.stringify(this.httpData)}
-
-Whitelisted URLs: ${NOIBUJS_CONFIG()[HTTP_DATA_PAYLOAD_URL_REGEXES_FLAG_NAME]}`,
-            false,
-            SEVERITY_ERROR,
-          );
-        }
       } else {
         // have collected more than the max number of http requests for this
         // page visit, so increment the over request limit count
@@ -96,7 +85,7 @@ Whitelisted URLs: ${NOIBUJS_CONFIG()[HTTP_DATA_PAYLOAD_URL_REGEXES_FLAG_NAME]}`,
       }
     }
     // if this was an error, send immediately so we don't lose it
-    if (isHttpCodeFailure(this.status)) {
+    if (isHttpCodeFailure(this.httpEvent.code)) {
       PageVisit.getInstance().addPageVisitEvent(
         {
           event: this.httpEvent,

package/dist/storage/rnStorageProvider.d.ts

@@ -0,0 +1,23 @@
+import StorageProvider from './storageProvider';
+/**
+ * React native storage provider implementation
+ */
+export default class RNStorageProvider extends StorageProvider {
+    /**
+     * Creates new instance
+     */
+    constructor();
+    /**
+     * Checks if storage is available
+     * @returns {Object}
+     */
+    static isAvailable(): Promise<{
+        result: boolean;
+        error: unknown;
+    }>;
+    /**
+     * Calculates used scape
+     * @returns {Number}
+     */
+    calculateUsedSize(): Promise<number>;
+}

package/dist/storage/rnStorageProvider.js

@@ -1,62 +1,33 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
 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);
-  }
+    /**
+     * Creates new instance
+     */
+    constructor() {
+        super(AsyncStorage);
+    }
+    /**
+     * Checks if storage is available
+     * @returns {Object}
+     */
+    static isAvailable() {
+        return StorageProvider.isAvailable(() => AsyncStorage);
+    }
+    /**
+     * Calculates used scape
+     * @returns {Number}
+     */
+    async calculateUsedSize() {
+        const keys = await AsyncStorage.getAllKeys();
+        const items = await AsyncStorage.multiGet(keys);
+        return items.reduce((sum, [key, item]) => sum + key.length + (item || '').length, 0);
+    }
 }
 
 export { RNStorageProvider as default };

package/dist/storage/storage.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Encapsulates storage api
+ */
+export default class Storage implements Noibu.Storage {
+    private readonly _isRNStorageAvailable;
+    private readonly _rnStorageError;
+    private static _instance;
+    private readonly _provider;
+    private readonly _type;
+    /**
+     * Creates new instance assessing available options
+     */
+    constructor();
+    /**
+     * Singleton
+     * @returns {Storage}
+     */
+    static getInstance(): Storage;
+    /** Checks if storage is available */
+    isAvailable(): Promise<boolean>;
+    /** Loads value from storage */
+    load<R = unknown>(key: string): Promise<R | null>;
+    /** Saves value to storage */
+    save(key: string, value: Noibu.StorageValue): Promise<void>;
+    /**
+     * Removes value from storage
+     * @param {String} key
+     */
+    remove(key: string): Promise<void>;
+    /** Calculates used scape */
+    calculateUsedSize(): Promise<number>;
+    /**
+     * Returns string indicating current provider type
+     * and availability for other storage types
+     * @returns {String}
+     */
+    getDiagnoseInfo(): Promise<string>;
+}

package/dist/storage/storage.js

@@ -1,119 +1,84 @@
-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';
+    _isRNStorageAvailable;
+    _rnStorageError;
+    static _instance;
+    _provider;
+    _type;
+    /**
+     * Creates new instance assessing available options
+     */
+    constructor() {
+        // todo replace with promise all if more storage available
+        const rnStorageAvailability = RNStorageProvider.isAvailable();
+        this._provider = rnStorageAvailability.then(({ result }) => result ? new RNStorageProvider() : null);
+        this._type = rnStorageAvailability.then(({ result }) => result ? 'RNStorage' : 'unavailable');
+        this._isRNStorageAvailable = rnStorageAvailability.then(({ result }) => result);
+        this._rnStorageError = rnStorageAvailability.then(({ error }) => error);
     }
-  }
-
-  /**
-   * Singleton
-   * @returns {Storage}
-   */
-  static getInstance() {
-    if (!this._instance) {
-      this._instance = new Storage();
+    /**
+     * Singleton
+     * @returns {Storage}
+     */
+    static getInstance() {
+        if (!this._instance) {
+            this._instance = new Storage();
+        }
+        return this._instance;
     }
-    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);
+    /** Checks if storage is available */
+    async isAvailable() {
+        return (await this._provider) !== null;
     }
-    return null;
-  }
-
-  /**
-   * Saves value to storage
-   * @param {String} key
-   * @param {String} value
-   */
-  save(key, value) {
-    if (this.isAvailable()) {
-      this._provider.save(key, value);
+    /** Loads value from storage */
+    async load(key) {
+        const provider = await this._provider;
+        if (provider !== null) {
+            return provider.load(key);
+        }
+        return null;
     }
-  }
-
-  /**
-   * Removes value from storage
-   * @param {String} key
-   */
-  remove(key) {
-    if (this.isAvailable()) {
-      this._provider.remove(key);
+    /** Saves value to storage */
+    async save(key, value) {
+        const provider = await this._provider;
+        if (provider !== null) {
+            return provider.save(key, value);
+        }
+        return undefined;
     }
-  }
-
-  /**
-   * Calculates used scape
-   * @returns {Number}
-   */
-  calculateUsedSize() {
-    if (this.isAvailable()) {
-      return this._provider.calculateUsedSize();
+    /**
+     * Removes value from storage
+     * @param {String} key
+     */
+    async remove(key) {
+        const provider = await this._provider;
+        if (provider !== null) {
+            return provider.remove(key);
+        }
+        return undefined;
+    }
+    /** Calculates used scape */
+    async calculateUsedSize() {
+        const provider = await this._provider;
+        if (provider !== null) {
+            return provider.calculateUsedSize();
+        }
+        return 0;
+    }
+    /**
+     * Returns string indicating current provider type
+     * and availability for other storage types
+     * @returns {String}
+     */
+    async getDiagnoseInfo() {
+        return `storage provider: ${await this
+            ._type} (rnStorage available: ${await this
+            ._isRNStorageAvailable}, error: ${await this._rnStorageError})`;
     }
-    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.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Base implementation for LocalStorage and SessionStorage
+ */
+export default abstract class StorageProvider {
+    _provider: Noibu.Provider;
+    /** Creates new instance based on provided provider type */
+    constructor(provider: Noibu.Provider);
+    /** Checks if provider is available */
+    static isAvailable(resolver: () => Noibu.Provider): Promise<{
+        result: boolean;
+        error: unknown;
+    }>;
+    /**
+     * Loads value from storage
+     */
+    load<R = Noibu.StorageValue>(key: string): Promise<R | null>;
+    /** Saves value to storage */
+    save(key: string, value: Noibu.StorageValue): Promise<void>;
+    /**
+     * Removes value from storage
+     * @param {String} key
+     */
+    remove(key: string): Promise<void>;
+    abstract calculateUsedSize(): Promise<number>;
+}

package/dist/storage/storageProvider.js

@@ -4,80 +4,47 @@ 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;
+    _provider;
+    /** Creates new instance based on provided provider type */
+    constructor(provider) {
+        this._provider = provider;
     }
-    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;
+    /** Checks if provider is available */
+    static async isAvailable(resolver) {
+        let result = true;
+        let error = null;
+        try {
+            const provider = resolver();
+            await provider.setItem(NOIBU_LOCAL_STORAGE_TEST_KEY, '0');
+            await provider.removeItem(NOIBU_LOCAL_STORAGE_TEST_KEY);
         }
-      }
+        catch (e) {
+            result = false;
+            error = e;
+        }
+        return { result, error };
+    }
+    /**
+     * Loads value from storage
+     */
+    async load(key) {
+        const value = await this._provider.getItem(key);
+        if (value !== null) {
+            return value;
+        }
+        return value;
+    }
+    /** Saves value to storage */
+    save(key, value) {
+        return this._provider.setItem(key, `${value}`);
+    }
+    /**
+     * Removes value from storage
+     * @param {String} key
+     */
+    remove(key) {
+        return this._provider.removeItem(key);
     }
-    return size;
-  }
 }
 
 export { StorageProvider as default };