noibu-react-native 0.0.2 → 0.0.3

package/README.md

@@ -97,19 +97,19 @@ const AlertHelpCode = () => {
 };
 ```
 
-#### `addCustomAttribute(name: string, value: string) => string`
+#### `addCustomAttribute(name: string, value: string) => Promise<string>`
 
 Adds a custom attribute to the session.
 
 - `@param {string} name` - Name of a custom attribute.
 - `@param {any} value` - It's value, should be a JSON.stringify-able type.
-- `@returns {string}` - A success message, or validation failure cause.
+- `@returns {Promise<string>}` - A success message, or validation failure cause.
 
 ```js
 import { NoibuJS } from 'noibu-react-native';
 
-NoibuJS.addCustomAttribute('myNameIs', 'Jeff'); // SUCCESS
-NoibuJS.addCustomAttribute('veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLong', 'Jeff'); // NAME_TOO_LONG
+NoibuJS.addCustomAttribute('myNameIs', 'Jeff'); // Promise<SUCCESS>
+NoibuJS.addCustomAttribute('veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLong', 'Jeff'); // Promise<NAME_TOO_LONG>
 ```
 
 #### `addError(customError: Error) => string`

package/dist/api/clientConfig.js

@@ -67,14 +67,14 @@ class ClientConfig {
 
   /** lockClient will disable the client script for a single pagevisit for
    * duration given in minuntes */
-  lockClient(duration, msg) {
+  async lockClient(duration, msg) {
     const expiryTime = new Date();
     expiryTime.setMinutes(expiryTime.getMinutes() + duration);
 
-    const noibuLSObject = this._getClientState();
+    const noibuLSObject = await this._getClientState();
     noibuLSObject[DISABLED_STATUS_KEY] = true;
     noibuLSObject[CLIENT_UNLOCK_TIME_KEY] = expiryTime;
-    this._storeBrowserData(noibuLSObject);
+    await this._storeBrowserData(noibuLSObject);
     this.postNoibuErrorAndOptionallyDisableClient(msg, true, SEVERITY_WARN);
   }
 
@@ -84,23 +84,23 @@ class ClientConfig {
   }
 
   /**  Updates the config object to store the given last active time */
-  updateLastActiveTime(lastActiveTime) {
+  async updateLastActiveTime(lastActiveTime) {
     this.lastActiveTime = lastActiveTime;
-    const newConfigData = this._getLsObject();
+    const newConfigData = await this._getLsObject();
     newConfigData[LAST_ACTIVE_TIME_KEY] = lastActiveTime;
-    this._storeBrowserData(newConfigData);
+    await this._storeBrowserData(newConfigData);
   }
 
   /**  Gets the current page visit sequence number that should be used */
-  getPageVisitSeq() {
-    if (this._pageVisitSeqNeedsReset()) {
+  async getPageVisitSeq() {
+    if (await this._pageVisitSeqNeedsReset()) {
       // Reset the page visit sequence number to zero and store the next seq number in storage
       this.pageVisitSeq = 0;
-      const newConfigData = this._getLsObject();
+      const newConfigData = await this._getLsObject();
       newConfigData[CURRENT_PAGE_VISIT_COUNT_KEY] = this.pageVisitSeq + 1;
       // Update the last active time since we are actively requesting the seq
       newConfigData[LAST_ACTIVE_TIME_KEY] = new Date();
-      this._storeBrowserData(newConfigData);
+      await this._storeBrowserData(newConfigData);
     }
 
     return this.pageVisitSeq;
@@ -118,9 +118,9 @@ class ClientConfig {
    * LastActiveTime: DATE OBJ
    * }
    */
-  _getLsObject() {
+  async _getLsObject() {
     const storage = Storage.getInstance();
-    const storedConfig = storage.load(NOIBU_BROWSER_ID_KYWRD);
+    const storedConfig = await storage.load(NOIBU_BROWSER_ID_KYWRD);
 
     // first time browsing since noibu was installed
     if (!storedConfig) {
@@ -151,8 +151,8 @@ class ClientConfig {
   /**
    * Check if we have surpased the last active time and the page visit seq number needs resetting
    */
-  _pageVisitSeqNeedsReset() {
-    const noibuLSObject = this._getClientState();
+  async _pageVisitSeqNeedsReset() {
+    const noibuLSObject = await this._getClientState();
     const someTimeAgo = new Date();
     someTimeAgo.setMinutes(
       someTimeAgo.getMinutes() - PV_SEQ_NUM_RESET_TIME_MINUTES,
@@ -164,11 +164,11 @@ class ClientConfig {
    * _setupStorageVars will set all class variables that depend
    * on the storage's value.
    */
-  _setupStorageVars() {
+  async _setupStorageVars() {
     const storage = Storage.getInstance();
-    if (!storage.isAvailable()) {
+    if (!(await storage.isAvailable())) {
       this.postNoibuErrorAndOptionallyDisableClient(
-        `Storage is unavailable, disabling client. ${storage.getDiagnoseInfo()}`,
+        `Storage is unavailable, disabling client. ${await storage.getDiagnoseInfo()}`,
         true,
         SEVERITY_ERROR,
       );
@@ -176,10 +176,10 @@ class ClientConfig {
     }
 
     // getting the current content of the storage
-    const noibuLSObject = this._getClientState();
+    const noibuLSObject = await this._getClientState();
 
     // Check if we have surpased the last active time and reset the sequence number if so
-    if (this._pageVisitSeqNeedsReset()) {
+    if (await this._pageVisitSeqNeedsReset()) {
       noibuLSObject[CURRENT_PAGE_VISIT_COUNT_KEY] = 0;
     }
 
@@ -219,7 +219,7 @@ class ClientConfig {
     }
 
     // we now check if we successfully saved the data
-    const savedData = this._storeBrowserData(noibuLSObject);
+    const savedData = await this._storeBrowserData(noibuLSObject);
 
     // if the browser is null, we cannot access the storage or an
     // error happened, thus we disable collect.
@@ -240,8 +240,8 @@ class ClientConfig {
    * Get it from storage if the expiry date is not in the past
    * Generate a brand new one if the expiry date is in the past
    */
-  _getClientState() {
-    const newConfigData = this._getLsObject();
+  async _getClientState() {
+    const newConfigData = await this._getLsObject();
 
     // if the lock expired, we remove the lock period and enable the client
     if (
@@ -250,7 +250,7 @@ class ClientConfig {
     ) {
       newConfigData[CLIENT_UNLOCK_TIME_KEY] = null;
       newConfigData[DISABLED_STATUS_KEY] = false;
-      this._storeBrowserData(newConfigData);
+      await this._storeBrowserData(newConfigData);
     }
     // return the stored browserId
     return newConfigData;
@@ -260,9 +260,8 @@ class ClientConfig {
    * _generateAndStoreData generates brand new data and then proceeds to store
    * it.
    */
-  _generateAndStoreData() {
-    const data = this._storeBrowserData(this._generateNewBrowserData());
-    return data;
+  async _generateAndStoreData() {
+    return this._storeBrowserData(this._generateNewBrowserData());
   }
 
   /**
@@ -291,25 +290,24 @@ class ClientConfig {
    * _storeBrowserData will store the passed object in storage.
    * @param  {} data the data to be stored
    */
-  _storeBrowserData(data) {
+  async _storeBrowserData(data) {
     const storage = Storage.getInstance();
     try {
-      storage.save(NOIBU_BROWSER_ID_KYWRD, stringifyJSON(data));
+      await storage.save(NOIBU_BROWSER_ID_KYWRD, stringifyJSON(data));
       return data;
     } catch (e) {
       this.postNoibuErrorAndOptionallyDisableClient(
         `Error writing browser data to storage, disabling client: ${e.message}, ` +
-          `${storage.getDiagnoseInfo()}`,
+          `${await storage.getDiagnoseInfo()}`,
         true,
         SEVERITY_ERROR,
       );
       // sending empty fields if we encountered errors while storing in the LS
-      const invalidData = {
+      return {
         [DISABLED_STATUS_KEY]: true,
         [BROWSER_ID_KEY]: null,
         [CURRENT_PAGE_VISIT_COUNT_KEY]: 0,
       };
-      return invalidData;
     }
   }
 
@@ -355,10 +353,10 @@ class ClientConfig {
       const expiryTime = new Date();
       expiryTime.setMinutes(expiryTime.getMinutes() + 10); // 10 minutes lock
 
-      const noibuLSObject = this._getClientState();
+      const noibuLSObject = await this._getClientState();
       noibuLSObject[DISABLED_STATUS_KEY] = true;
       noibuLSObject[CLIENT_UNLOCK_TIME_KEY] = expiryTime;
-      this._storeBrowserData(noibuLSObject);
+      await this._storeBrowserData(noibuLSObject);
       this.isClientDisabled = true;
       // end of lock
       // overriding the message to be an alert that we are shutting collect off.

package/dist/api/helpCode.js

@@ -32,8 +32,8 @@ class HelpCode {
    * @returns {Promise<string>} Promise object representing the help code request.
    * @throws {string} Throws an error if the noibu connection is unavailable.
    */
-  requestHelpCode() {
-    if (this.requestContext != null) {
+  async requestHelpCode() {
+    if (this.requestContext !== null) {
       return this.requestContext.promise;
     }
 
@@ -50,7 +50,7 @@ class HelpCode {
 
     this.requestContext = context;
 
-    const result = this._sendRequest();
+    const result = await this._sendRequest();
 
     if (result === false) {
       this.requestContext = null;

package/dist/api/inputManager.js

@@ -54,7 +54,7 @@ class InputManager {
    * gets the sdk object that will be assigned to a window variable
    * @returns {{
    *    requestHelpCode: (alert?: boolean) => Promise<string>,
-   *    addCustomAttribute: (name: string, value: string) => string,
+   *    addCustomAttribute: (name: string, value: string) => Promise<string>,
    *    addError: (customError: Error) => string,
    *    addJsSdkError: (customError: string, errorSource: string) => string
    * }}
@@ -157,7 +157,7 @@ class InputManager {
    * @param  {} name
    * @param  {} value
    */
-  _addCustomAttribute(name, value) {
+  async _addCustomAttribute(name, value) {
     // we return if we are over the limit of ids
     if (Object.keys(this.customIDs).length >= MAX_CUSTOM_IDS_PER_PAGEVISIT) {
       return this.TOO_MANY_IDS_ADDED_MSG;
@@ -176,7 +176,7 @@ class InputManager {
     }
 
     this.customIDs[name] = value;
-    MetroplexSocket.getInstance().sendMessage(META_DATA_METROPLEX_TYPE, {
+    await MetroplexSocket.getInstance().sendMessage(META_DATA_METROPLEX_TYPE, {
       [PAGE_VISIT_META_DATA_ATT_NAME]: {
         [CUSTOM_ID_NAME_TYPE]: name,
         [CUSTOM_ID_VALUE_TYPE]: value,
@@ -225,8 +225,8 @@ class InputManager {
    * @param {boolean} [alertUser=true] - Whether to alert the user about the help code request.
    * @returns {Promise<string>} A promise that resolves with the requested help code.
    */
-  _requestHelpCode(alertUser = true) {
-    return HelpCode.getInstance().requestHelpCode(alertUser);
+  _requestHelpCode() {
+    return HelpCode.getInstance().requestHelpCode();
   }
 }
 

package/dist/api/metroplexSocket.js

@@ -161,9 +161,9 @@ class MetroplexSocket {
    * Queues the message if the connection isn't open yet.
    * @param  {} type
    * @param  {} payload
-   * @returns {boolean} true if message was sent succefully, false otherwise
+   * @returns {Promise<boolean>} true if message was sent succefully, false otherwise
    */
-  sendMessage(type, payload) {
+  async sendMessage(type, payload) {
     // if we have a lock on this specific type, we dont send it
     if (
       type in this.metroplexTypeLock ||
@@ -183,7 +183,7 @@ class MetroplexSocket {
       this.retryMessageQueue.push({ payload: payloadData, type });
       StoredPageVisit.getInstance().checkAndStoreRetryQueue(
         this.retryMessageQueue,
-        this.getPageInformation(),
+        await this.getPageInformation(),
       );
     }
 
@@ -261,7 +261,7 @@ class MetroplexSocket {
     });
     this.socketInstanceId = uuid.v4();
 
-    this.socket.onerror = () => {
+    this.socket.onerror = e => {
       // use for metrics
       // there is no useful error message/description from this event
     };
@@ -392,23 +392,21 @@ class MetroplexSocket {
       this.sessionLength = delta;
     }
 
-    const endTime = new Date(
-      this.sessionTimestamp.getTime() + delta,
-    ).toISOString();
-
     // Assigning this value here is much better than copying the whole object.
     // eslint-disable-next-line no-param-reassign
-    payload[END_AT_ATT_NAME] = endTime;
+    payload[END_AT_ATT_NAME] = new Date(
+      this.sessionTimestamp.getTime() + delta,
+    ).toISOString();
   }
 
   /** open handler for socket */
-  _onSocketOpen() {
+  async _onSocketOpen() {
     // if we are not connected, we do not send any messages
     if (!this.isConnected() || ClientConfig.getInstance().isClientDisabled) {
       return;
     }
 
-    this._sendSocketMessage(this.getPageInformation());
+    this._sendSocketMessage(await this.getPageInformation());
     // Set this to allow normal page visit and video frag messages to be sent
     this.pageVisitInfoSent = true;
     this.currentConnectionAttempts = 0;
@@ -628,7 +626,7 @@ class MetroplexSocket {
    * will try to empty both the queues with beacons.
    * @param  {} maxMessageSize
    */
-  postFullPageVisit(maxMessageSize) {
+  async postFullPageVisit(maxMessageSize) {
     if (this.retryMessageQueue.length === 0) {
       return;
     }
@@ -642,14 +640,14 @@ class MetroplexSocket {
 
     let currentMsgPayloadSize = 0;
     let currentCompletePv = {
-      [PAGE_VISIT_INFORMATION_ATT_NAME]: this.getPageInformation(),
+      [PAGE_VISIT_INFORMATION_ATT_NAME]: await this.getPageInformation(),
       [PAGE_VISIT_PART_ATT_NAME]: [],
       [PAGE_VISIT_VID_FRAG_ATT_NAME]: [],
       [PAGE_VISIT_HTTP_DATA_ATT_NAME]: [],
       [VIDEO_PART_COUNT_ATT_NAME]: this.connectionCount,
     };
     currentCompletePv[PAGE_VISIT_INFORMATION_ATT_NAME][IS_LAST_ATT_NAME] = true;
-
+    const pageInfo = await this.getPageInformation();
     this.retryMessageQueue.forEach(msg => {
       // can't use two variables types in obj deconstruction
       // eslint-disable-next-line  prefer-const
@@ -674,9 +672,9 @@ class MetroplexSocket {
 
         // resetting currentCompletePv, since we need to keep adding
         // events to a blank object to send to metroplex.
-        // retain the video part count so we don't overwrite anything
+        // retain the video part count, so we don't overwrite anything
         currentCompletePv = {
-          [PAGE_VISIT_INFORMATION_ATT_NAME]: this.getPageInformation(),
+          [PAGE_VISIT_INFORMATION_ATT_NAME]: pageInfo,
           [PAGE_VISIT_PART_ATT_NAME]: [],
           [PAGE_VISIT_VID_FRAG_ATT_NAME]: [],
           [PAGE_VISIT_HTTP_DATA_ATT_NAME]: [],
@@ -822,12 +820,12 @@ class MetroplexSocket {
   }
 
   /** will get page information, calling this will increase the connection count */
-  getPageInformation() {
+  async getPageInformation() {
     const pvi = {
       [BROWSER_ID_ATT_NAME]: ClientConfig.getInstance().browserId,
       [PV_ID_ATT_NAME]: ClientConfig.getInstance().pageVisitId,
       [VER_ATT_NAME]: CURRENT_PV_VERSION,
-      [PV_SEQ_ATT_NAME]: ClientConfig.getInstance().getPageVisitSeq(),
+      [PV_SEQ_ATT_NAME]: await ClientConfig.getInstance().getPageVisitSeq(),
       [ON_URL_ATT_NAME]: this.initialURL,
       [REF_URL_ATT_NAME]: this.initialReferingURL,
       [STARTED_AT_ATT_NAME]: this.sessionTimestamp.toISOString(),

package/dist/api/storedPageVisit.js

@@ -19,9 +19,9 @@ class StoredPageVisit {
     this.flushedStorage = false;
 
     const storage = Storage.getInstance();
-    if (storage.isAvailable()) {
-      this._postPreviousPageVisit();
-    }
+    storage.isAvailable().then(isAvailable => {
+      if (isAvailable) this._postPreviousPageVisit();
+    });
   }
 
   /** gets the singleton instance */
@@ -88,8 +88,8 @@ class StoredPageVisit {
    * @param  {} pageVisitFrags
    * @param  {} pvInfo
    */
-  _writePageVisitFrags(pageVisitFrags, pvInfo) {
-    // Create a new object to write to storage that doesnt have the timeout and flush members
+  async _writePageVisitFrags(pageVisitFrags, pvInfo) {
+    // Create a new object to write to storage that doesn't have the timeout and flush members
     const lsPageVisit = {
       pageVisitFrags,
       pageVisitInfo: pvInfo,
@@ -101,17 +101,17 @@ class StoredPageVisit {
     const json = stringifyJSON(lsPageVisit);
 
     try {
-      storage.save(NOIBU_STORED_PAGE_VISIT, json);
+      await storage.save(NOIBU_STORED_PAGE_VISIT, json);
     } catch (err) {
-      storage.remove(NOIBU_STORED_PAGE_VISIT);
+      await storage.remove(NOIBU_STORED_PAGE_VISIT);
 
       // Calculate current storage size
-      const size = storage.calculateUsedSize();
+      const size = await storage.calculateUsedSize();
 
       ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(
         `Error writing pv to storage: ${err}, ` +
           `json size: ${json.length}, storage size: ${size}, ` +
-          `${storage.getDiagnoseInfo()}`,
+          `${await storage.getDiagnoseInfo()}`,
         false,
         SEVERITY_ERROR,
       );
@@ -122,11 +122,11 @@ class StoredPageVisit {
    * Read the stored page visit from storage, create a complete page visit object
    * and then post that to Metroplex
    */
-  _getPostData() {
+  async _getPostData() {
     const storage = Storage.getInstance();
 
     // Read the storedPageVisit from storage
-    const data = storage.load(NOIBU_STORED_PAGE_VISIT);
+    const data = await storage.load(NOIBU_STORED_PAGE_VISIT);
     if (!data) {
       return null;
     }
@@ -136,7 +136,7 @@ class StoredPageVisit {
       storedPageVisit = JSON.parse(data);
     } catch (e) {
       // Remove the item since there is something corrupted
-      storage.remove(NOIBU_STORED_PAGE_VISIT);
+      await storage.remove(NOIBU_STORED_PAGE_VISIT);
       ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(
         `Error parsing page visit string '${data}': ${e}`,
         false,
@@ -210,24 +210,22 @@ class StoredPageVisit {
   /** Returns a promise that resolves to post the page visit in storage to Metroplex */
   _getPostPageVisitPromise() {
     return new Promise((resolve, reject) => {
-      const data = this._getPostData();
-
-      if (!data) {
-        resolve();
-        return;
-      }
-
-      const headers = {
-        'content-type': 'application/json',
-      };
-
-      makeRequest('POST', GET_METROPLEX_POST_URL(), data, headers, 2000, true)
-        .then(() => {
+      this._getPostData().then(data => {
+        if (!data) {
           resolve();
-        })
-        .catch(e => {
-          reject(new Error('Page visit post request rejected due to: ', e));
-        });
+          return;
+        }
+
+        const headers = {
+          'content-type': 'application/json',
+        };
+
+        makeRequest('POST', GET_METROPLEX_POST_URL(), data, headers, 2000, true)
+          .then(resolve)
+          .catch(e => {
+            reject(new Error('Page visit post request rejected due to: ', e));
+          });
+      });
     });
   }
 }

package/dist/constants.d.ts

@@ -46,7 +46,6 @@ export declare const MAX_PAGEVISIT_VISITED: 300;
 export declare const IMG_EXTENSIONS: readonly ["jpg", "jpeg", "bmp", "gif", "png"];
 export declare const MAX_PAGEVISIT_EVENTS: 200;
 export declare const POSSIBLE_HTML_ATTRIBUTES_FOR_TEXT_VALUES: string[];
-export declare const debug: (...m: any[]) => void;
 export declare const MAX_CUSTOM_IDS_PER_PAGEVISIT: 10;
 export declare const MAX_CUSTOM_ERRORS_PER_PAGEVISIT: 500;
 export declare const NOIBUJS_SDK_NAME: "NOIBUJS";

package/dist/constants.js

@@ -379,13 +379,10 @@ function IS_NJS_VERSION_BETA() {
  */
 function GET_MAX_METROPLEX_RECONNECTION_NUMBER() {
     try {
-        // webpack variable
-        // eslint-disable-next-line no-undef
-        const maxConnNum = "20";
-        return maxConnNum;
+        return "20";
     }
     catch (err) {
-        // during testing we only try to connect twice before abandoning
+        // during testing, we only try to connect twice before abandoning
         return 2;
     }
 }
@@ -396,13 +393,10 @@ function GET_MAX_METROPLEX_RECONNECTION_NUMBER() {
  */
 function GET_METROPLEX_CONSECUTIVE_CONNECTION_DELAY() {
     try {
-        // webpack variable
-        // eslint-disable-next-line no-undef
-        const consecConnDelay = "1000";
-        return consecConnDelay;
+        return "1000";
     }
     catch (err) {
-        // during testing we only delay by 1 second
+        // during testing, we only delay by 1 second
         return 1000;
     }
 }
@@ -481,10 +475,7 @@ function GET_METROPLEX_METRICS_URL() {
  */
 function JS_ENV() {
     try {
-        // webpack variable
-        // eslint-disable-next-line no-undef
-        const currEnv = CURR_ENV;
-        return currEnv;
+        return CURR_ENV;
     }
     catch (err) {
         return 'test';

package/dist/entry/index.d.ts

@@ -8,7 +8,7 @@ export declare const setupNoibu: (config: {
 }) => void;
 export declare const NoibuJS: {
     requestHelpCode: (alert?: boolean | undefined) => Promise<string>;
-    addCustomAttribute: (name: string, value: string) => string;
+    addCustomAttribute: (name: string, value: string) => Promise<string>;
     addError: (customError: Error) => string;
     addJsSdkError: (customError: string, errorSource: string) => string;
 };

package/dist/monitors/errorMonitor.js

@@ -126,7 +126,7 @@ function monitorErrors() {
         saveErrorToPagevisit(ERROR_EVENT_ERROR_TYPE, {
             error,
         });
-    }, true);
+    });
     if (global.HermesInternal) {
         global.HermesInternal.enablePromiseRejectionTracker({
             allRejections: true,

package/dist/monitors/locationChangeMonitor.js

@@ -1,6 +1,7 @@
 import 'react-native-device-info';
 import 'react-native-localize';
 import 'react-native-uuid';
+import '@react-native-async-storage/async-storage';
 
 /** @module LocationMonitor */
 

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,118 +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) {
-      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,79 +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();
-      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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "noibu-react-native",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "React-Native SDK for NoibuJS to collect errors in React-Native applications",
   "main": "dist/entry/index.js",
   "types": "dist/entry/index.d.ts",
@@ -23,6 +23,7 @@
   "dependencies": {
     "react": ">=16.11.0",
     "react-native": ">=0.63.0",
+    "@react-native-async-storage/async-storage": "^1.19.0",
     "react-native-device-info": "^10.6.0",
     "react-native-url-polyfill": "^1.3.0",
     "react-native-uuid": "^2.0.1",

package/dist/storage/localStorageProvider.js

@@ -1,23 +0,0 @@
-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/sessionStorageProvider.js

@@ -1,23 +0,0 @@
-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 };