noibu-react-native 0.2.7 → 0.2.8

package/dist/monitors/http-tools/HTTPDataBundler.js

@@ -1,11 +1,13 @@
 import { __awaiter } from 'tslib';
-import { SEVERITY, CONTENT_TYPE, PII_REDACTION_REPLACEMENT_STRING } from '../../constants.js';
+import { CONTENT_TYPE, PII_REDACTION_REPLACEMENT_STRING } from '../../constants.js';
 import ClientConfig from '../../api/ClientConfig.js';
 import StoredMetrics from '../../api/StoredMetrics.js';
 import { safeFromEntries, safeEntries } from '../../utils/object.js';
 import { safeTrim, stringifyJSON } from '../../utils/function.js';
 import { removePII } from '../../utils/piiRedactor.js';
 import { Singleton } from '../BaseMonitor.js';
+import '../../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
+import { Severity } from '../../node_modules/@noibu/metroplex-ts-bindings/dist/Severity.js';
 
 const DEFAULT_WEBSITE_SUBDOMAIN_PATTERN = /^www\d{0,2}$/;
 const CONTENT_LENGTH = 'content-length';
@@ -60,7 +62,7 @@ class HTTPDataBundler extends Singleton {
                 this.initialURLPartsReversed.reverse();
             }
             catch (e) {
-                ClientConfig.getInstance().postInternalError({ msg: `Unable to determine hostname for initial URL`, error: e }, false, SEVERITY.warn);
+                ClientConfig.getInstance().postInternalError({ msg: `Unable to determine hostname for initial URL`, error: e }, false, Severity.WARN);
             }
         }
         this.httpDataCollectionEnabled = !!ClientConfig.getInstance().enableHttpDataCollection;
@@ -165,7 +167,7 @@ class HTTPDataBundler extends Singleton {
                     return text;
                 }
                 catch (e) {
-                    ClientConfig.getInstance().postInternalError({ msg: `Unable to stringify JSON response`, error: e }, false, SEVERITY.warn);
+                    ClientConfig.getInstance().postInternalError({ msg: `Unable to stringify JSON response`, error: e }, false, Severity.WARN);
                     return null;
                 }
             }
@@ -284,7 +286,7 @@ class HTTPDataBundler extends Singleton {
             ClientConfig.getInstance().postInternalError({
                 msg: `restrictPayload received non string payload`,
                 payloadType: typeof payload,
-            }, false, SEVERITY.error);
+            }, false, Severity.ERROR);
             return HTTP_BODY_NULL_STRING;
         }
         if (payload === HTTP_BODY_NULL_STRING ||
@@ -428,7 +430,7 @@ class HTTPDataBundler extends Singleton {
             return stringifyJSON(value);
         }
         catch (e) {
-            ClientConfig.getInstance().postInternalError({ msg: `Unable to stringify request body`, error: e }, false, SEVERITY.warn);
+            ClientConfig.getInstance().postInternalError({ msg: `Unable to stringify request body`, error: e }, false, Severity.WARN);
         }
         return null;
     }

package/dist/monitors/integrations/ReactNativeNavigationIntegration.d.ts

@@ -0,0 +1,17 @@
+import { NavigationDelegate } from 'react-native-navigation/lib/dist/src/NavigationDelegate';
+import { Singleton } from '../BaseMonitor';
+/** react-native-navigation adapter */
+export declare class ReactNativeNavigationIntegration extends Singleton implements NavigationIntegration {
+    private stack;
+    private stackPointers;
+    private registration;
+    /** Attaches provided listeners to the integration */
+    register(navigation: NavigationDelegate, onNavigation: (breadcrumbs: string[]) => void): void;
+    /**
+     * Listens to ComponentWillAppear events, keeps track of visited screens and
+     * pops them if the same page is visited to prevent cycles
+     */
+    private getListener;
+    /** Destructor */
+    protected destroy(): void;
+}

package/dist/pageVisit/EventDebouncer.d.ts

@@ -0,0 +1,23 @@
+import { Singleton } from '../monitors/BaseMonitor';
+import { EventType, PageVisitEvent, UserStepType } from '@noibu/metroplex-ts-bindings';
+/**
+ * Singleton class responsible for debouncing all events
+ * that are registered
+ */
+export declare class EventDebouncer extends Singleton {
+    private readonly debouncePeriods;
+    private readonly timeouts;
+    private readonly events;
+    /** Creates an instance of EventDebouncer */
+    constructor();
+    /**
+     * Creates an event object with the event and the time it was added then pushes
+     * that event object to the queue of events waiting to be debounced.
+     */
+    debounce(event: Omit<PageVisitEvent, 'occ_at'>): void;
+    /** Debounce function to be executed once the debounce period is completed */
+    sendEvents: (type: EventType | UserStepType) => void;
+    /** Sets up the page hide handler to try to push remaining events in the queues */
+    _setupUnloadHandler(): void;
+    protected destroy(): void;
+}

package/dist/pageVisit/HttpEventManager.d.ts

@@ -0,0 +1,14 @@
+import { NoSeq } from '../types/Metroplex';
+import { PageVisitEventHTTP, RawHttpData } from '@noibu/metroplex-ts-bindings';
+/** Saves the HTTP event to the pageVisit Queue */
+export declare function saveHTTPEvent(httpEvent: Partial<PageVisitEventHTTP>, httpData?: NoSeq<RawHttpData> | null, isGqlError?: boolean): number | undefined;
+/** Determines if a response is a failure */
+export declare function isHttpCodeFailure(code: unknown): boolean;
+/**
+ * Checks if sending data is allowed based on the HTTP status code and count.
+ * status - The HTTP status code to evaluate.
+ * count - The count of events to consider.
+ * isGqlError - Whether the context is considered as a GQL error.
+ * Returns `true` if sending data is allowed, `false` otherwise.
+ */
+export declare function isSendAllowed(status: number, count: number, isGqlError?: boolean): boolean;

package/dist/pageVisit/PageVisitManager.d.ts

@@ -0,0 +1,31 @@
+import { Singleton } from '../monitors/BaseMonitor';
+import { PageVisitEvent } from '@noibu/metroplex-ts-bindings';
+/**
+ * Singleton class to hold all the information
+ * about the gathered errors throught the session
+ */
+export declare class PageVisitManager extends Singleton {
+    partCounter: number;
+    pvEvents: PageVisitEvent[];
+    pvEventLength: number;
+    visibilityChangedCounter: number;
+    totalPvEventLength: number;
+    /** adds page visit events into the current page visit map and then sends a page visit message
+     */
+    addPageVisitEvents(eventObjects: PageVisitEvent[]): void;
+    /**
+     * adds the page visit event into the current page visit map and then sends a page visit message
+     * returns the key to access this event in the map
+     */
+    addPageVisitEvent(eventObj: Omit<PageVisitEvent, 'occ_at'>): void;
+    /**
+     * adds a new page visit event into the current page visit map and returns the
+     * the key to access this event in the map
+     */
+    _addPageVisitEvent(pvEvent: PageVisitEvent): void;
+    /**
+     * _sendPageVisitMessage will reset the buffer and post the current
+     * content to metroplex
+     */
+    _sendPageVisitMessage(): void;
+}

package/dist/pageVisit/pageVisitEventError.d.ts

@@ -0,0 +1,12 @@
+import { Option, PageVisitEventError } from '@noibu/metroplex-ts-bindings';
+import { EventInput, PageVisitErrorInput } from '../types/PageVisitErrors';
+/**
+ * gets the onURL of a string, defaulting to the location of the webpage
+ */
+export declare function getOnURL(realOnURL: unknown): string;
+/**
+ * determines if an error is a collect error
+ */
+export declare function isErrorCollectedByNoibu(pvError: PageVisitEventError): Promise<false | void>;
+/** Saves the error to the Error queue */
+export declare function saveErrorToPagevisit<T extends PageVisitErrorInput | EventInput>(payload: T, httpDataSeqNum?: Option<number>): void;

package/dist/pageVisit/pageVisitEventError.js

@@ -1,12 +1,12 @@
 import { __awaiter } from 'tslib';
 import { isValidURL, getJSStack, stringifyJSON, getMaxSubstringAllowed, asString } from '../utils/function.js';
-import { SEVERITY } from '../constants.js';
 import ClientConfig from '../api/ClientConfig.js';
 import StoredMetrics from '../api/StoredMetrics.js';
 import { EventDebouncer } from './EventDebouncer.js';
 import '../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
 import { PageVisitErrorSource } from '../node_modules/@noibu/metroplex-ts-bindings/dist/PageVisitErrorSource.js';
 import { EventType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/EventType.js';
+import { Severity } from '../node_modules/@noibu/metroplex-ts-bindings/dist/Severity.js';
 import { ErrorType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/ErrorType.js';
 
 const BLOCKLISTED_DOMAINS = {
@@ -170,7 +170,7 @@ function isErrorCollectedByNoibu(pvError) {
         // checking if this error originated from the Noibu script
         const msg = getCollectErrorMsg(pvError);
         if (msg) {
-            return ClientConfig.getInstance().postInternalError({ msg, pvError }, false, SEVERITY.error);
+            return ClientConfig.getInstance().postInternalError({ msg, pvError }, false, Severity.ERROR);
         }
         return false;
     });

package/dist/react/ErrorBoundary.d.ts

@@ -0,0 +1,67 @@
+import * as React from 'react';
+export type FallbackRender = (errorData: {
+    error: Error;
+    componentStack: string | null;
+    eventId: string | null;
+    resetError(): void;
+}) => React.ReactElement;
+export type ErrorBoundaryProps = {
+    children?: React.ReactNode | (() => React.ReactNode);
+    /**
+     * Target fallback component that gets rendered when the error boundary encounters an error.
+     *
+     * Can either provide a React Component, or a function that returns React Component as
+     * a valid fallback prop. If a function is provided, the function will be called with
+     * the error, the component stack, and a function that resets the error boundary on error.
+     *
+     */
+    fallback?: React.ReactElement | FallbackRender;
+    /** Called when the error boundary encounters an error */
+    onError?(error: Error, componentStack: string, eventId: string): void;
+    /** Called on componentDidMount() */
+    onMount?(): void;
+    /** Called if resetError() is called from the fallback render props function  */
+    onReset?(error: Error | null, componentStack: string | null, eventId: string | null): void;
+    /** Called on componentWillUnmount() */
+    onUnmount?(error: Error | null, componentStack: string | null, eventId: string | null): void;
+};
+export type ErrorBoundaryState = {
+    componentStack: React.ErrorInfo['componentStack'] | null;
+    error: Error | null;
+    eventId: string | null;
+};
+/**
+ * @description Target ErrorBoundary component that logs errors to Noibu. Requires React >= 16.
+ * @extends {Component<ErrorBoundaryProps, ErrorBoundaryState>}
+ */
+export declare class ErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    state: ErrorBoundaryState;
+    /**
+     * Lifecycle hook on mount
+     * @returns void
+     */
+    componentDidMount(): void;
+    /**
+     *
+     * Handler for all errors that happen in a wrapped component
+     * @param  {Error&{cause?:Error}} error
+     * @param  {React.ErrorInfo} {componentStack}
+     * @returns void
+     */
+    componentDidCatch(error: Error & {
+        cause?: Error;
+    }, { componentStack }: React.ErrorInfo): void;
+    /**
+     *  * Lifecycle hook on unmount
+     * @returns void
+     */
+    componentWillUnmount(): void;
+    /** Callback from fallback to reset the error boundary */
+    resetErrorBoundary: () => void;
+    /**
+     *
+     * Renders the fallback ui
+     * @returns {React.ReactNode}
+     */
+    render(): React.ReactNode;
+}

package/dist/sessionRecorder/SessionRecorder.d.ts

@@ -0,0 +1,50 @@
+import { RecorderEvent } from './nativeSessionRecorderSubscription';
+import { Singleton } from '../monitors/BaseMonitor';
+/** Singleton class to record user sessions */
+export default class SessionRecorder extends Singleton {
+    private eventBuffer;
+    private vfCounter;
+    private didSetupRecorder;
+    private isVideoLengthNegativeInvalid;
+    private lastFragPostTimestamp;
+    private pauseTimeout;
+    private lastRecordedTimestamp;
+    private firstRecordedTimestamp;
+    private recordStopper;
+    private freezingEvents;
+    /** Setups the SessionRecorder instance for usage */
+    constructor();
+    /** Sets up the page hide handler to try to push remaining video events */
+    setupUnloadHandler(): void;
+    /** Sets up the post metrics handler to potentially log a debug message */
+    setupPostMetricsHandler(): void;
+    /** Starts recording the user session */
+    recordUserSession(): Promise<void>;
+    /**
+     * handleNewRRwebEvent will process each upcoming.
+     * rrweb event. It will make sure that the current buffer
+     * is updated with the latest events and post the contents
+     * of the buffer if it exceeds max size
+     */
+    handleRecorderEvent(recorderEvent: RecorderEvent): Promise<void>;
+    /** Compress event */
+    private pack;
+    /** Compresses the snapshot */
+    private static compress;
+    /** builds a log message with debug info */
+    buildDebugMessage(eventName: string, totalVideoTime: number, sessionLength: number): string;
+    /**
+     * handleFragPost communicates with the Metroplex socket
+     * to post video fragments when needed. It also handles
+     * necessary management of the buffer and it's related
+     * variables
+     */
+    handleFragPost(): Promise<void>;
+    /**
+     * unfreeze forcefully resumes recording events in case it was frozen
+     * waiting for user events
+     */
+    unfreeze(): Promise<void>;
+    /** stops recording */
+    private freeze;
+}

package/dist/sessionRecorder/SessionRecorder.js

@@ -4,13 +4,14 @@ import { LogLevel, initialize, subscribeToNativeEvent } from './nativeSessionRec
 import StoredMetrics from '../api/StoredMetrics.js';
 import ClientConfig from '../api/ClientConfig.js';
 import { stringifyJSON } from '../utils/function.js';
-import { SEVERITY, MAX_TIME_FOR_UNSENT_DATA_MILLIS } from '../constants.js';
+import { MAX_TIME_FOR_UNSENT_DATA_MILLIS } from '../constants.js';
 import MetroplexSocket from '../api/MetroplexSocket.js';
 import { addSafeEventListener } from '../utils/eventlistener.js';
 import { noibuLog } from '../utils/log.js';
 import { Platform } from 'react-native';
 import { Singleton } from '../monitors/BaseMonitor.js';
 import '../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
+import { Severity } from '../node_modules/@noibu/metroplex-ts-bindings/dist/Severity.js';
 import { WebsocketMessageType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/WebsocketMessageType.js';
 
 // custom event name for posting metrics
@@ -78,7 +79,7 @@ class SessionRecorder extends Singleton {
                     eventName,
                     totalVideoTime,
                     sessionLength,
-                }, clientDisabled, SEVERITY.warn);
+                }, clientDisabled, Severity.WARN);
             }
         });
     }
@@ -147,7 +148,7 @@ class SessionRecorder extends Singleton {
             // If we don't adjust for time, we assume that the expected video length is
             // the difference between the first recorded timestamp and the last recorded timestamp.
             if (this.firstRecordedTimestamp && timestamp < this.firstRecordedTimestamp) {
-                ClientConfig.getInstance().postInternalError({ msg: `Detected time rewind. Client has been disabled.` }, true, SEVERITY.error, true);
+                ClientConfig.getInstance().postInternalError({ msg: `Detected time rewind. Client has been disabled.` }, true, Severity.ERROR, true);
                 return;
             }
             const packedEvent = yield this.pack(recorderEvent.message);
@@ -216,7 +217,7 @@ class SessionRecorder extends Singleton {
                         totalVideoTime,
                         'start time': this.firstRecordedTimestamp,
                         'end time': this.lastRecordedTimestamp,
-                    }, false, SEVERITY.error);
+                    }, false, Severity.ERROR);
                     this.isVideoLengthNegativeInvalid = true;
                     totalVideoTime = 0;
                 }
@@ -243,7 +244,7 @@ class SessionRecorder extends Singleton {
             }
             catch (err) {
                 // letting collect know we are closing the rrweb listener
-                ClientConfig.getInstance().postInternalError({ msg: `video frag socket closed with err: ${err.message}` }, false, SEVERITY.error);
+                ClientConfig.getInstance().postInternalError({ msg: `video frag socket closed with err: ${err.message}` }, false, Severity.ERROR);
                 // if we detect an error in the frag posting, we stop recording
                 // the video
                 this.freeze();
@@ -270,7 +271,7 @@ class SessionRecorder extends Singleton {
                 this.recordStopper();
             }
             catch (e) {
-                ClientConfig.getInstance().postInternalError({ msg: `Error during handleFragPost in recordStopper: ${e}` }, false, SEVERITY.error);
+                ClientConfig.getInstance().postInternalError({ msg: `Error during handleFragPost in recordStopper: ${e}` }, false, Severity.ERROR);
             }
         }
     }

package/dist/sessionRecorder/nativeSessionRecorderSubscription.d.ts

@@ -0,0 +1,77 @@
+/** The level of logging to show in the device logcat stream. */
+export declare enum LogLevel {
+    Verbose = "Verbose",
+    Debug = "Debug",
+    Info = "Info",
+    Warning = "Warning",
+    Error = "Error",
+    None = "None"
+}
+/**
+ * The configuration that will be used to customize the session recording behaviour.
+ *
+ * @param userId        [OPTIONAL default = null] Target custom identifier for the current user. If passed as null, the user id
+ *                      will be auto generated. The user id in general is sticky across sessions.
+ *                      The provided user id must follow these conditions:
+ *                          1. Cannot be an empty string.
+ *                          2. Should be base36 and smaller than "1Z141Z4".
+ * @param logLevel      [OPTIONAL default = LogLevel.None] The level of logging to show in the device logcat stream.
+ * @param allowMeteredNetworkUsage  [OPTIONAL default = false] Allows uploading session data to the servers on device metered network.
+ * @param enableWebViewCapture    [OPTIONAL default = true] Allows Noibu - Session recorder to capture the web views DOM content.
+ * @param allowedDomains    [OPTIONAL default = ["*"]] The whitelisted domains to allow Noibu - Session recorder to capture their DOM content.
+ *                          If it contains "*" as an element, all domains will be captured.
+ * @param disableOnLowEndDevices [OPTIONAL default = false] Disable Noibu - Session recorder on low-end devices.
+ * @param maximumDailyNetworkUsageInMB [OPTIONAL default = null] Maximum daily network usage for Noibu - Session recorder (null = No limit). When the limit is reached, Noibu - Session recorder will turn on lean mode.
+ */
+export interface SessionRecorderConfig {
+    userId?: string | null;
+    logLevel?: LogLevel;
+    allowMeteredNetworkUsage?: boolean;
+    enableWebViewCapture?: boolean;
+    allowedDomains?: string[];
+    disableOnLowEndDevices?: boolean;
+    maximumDailyNetworkUsageInMB?: number;
+}
+/**
+ * Initializes the Noibu - Session recording SDK if the API level is supported.
+ * param projectId     [REQUIRED] The session recording project id to send data to.
+ * param config   [OPTIONAL] The sessionreplay config, if not provided default values are used.
+ */
+export declare function initialize(projectId: string, config?: SessionRecorderConfig): void;
+/**
+ * Sets a custom user id that can be used to identify the user. It has less
+ * restrictions than the userId parameter. You can pass any string and
+ * you can filter on it on the dashboard side. If you need the most efficient
+ * filtering on the dashboard, use the userId parameter if possible.
+ * <p>
+ * Note: custom user id cannot be null or empty, or consists only of whitespaces.
+ * </p>
+ * @param customUserId   The custom user id to set.
+ */
+export declare function setCustomUserId(customUserId: string): void;
+/**
+ * Sets a custom session id that can be used to identify the session.
+ * <p>
+ * Note: custom session id cannot be null or empty, or consists only of whitespaces.
+ * </p>
+ * @param customSessionId   The custom session id to set.
+ */
+export declare function setCustomSessionId(customSessionId: string): void;
+export type RecorderEvent = import('./types').RecorderEvent;
+export type UnsubscribeFn = import('./types').UnsubscribeFn;
+/**
+ * Subscribes to a native event emitted by the Noibu Session Recorder.
+ *
+ * This function listens for the `noibuRecordingEvent` emitted from the native layer (only on Android)
+ * and invokes the provided callback whenever the event occurs. If the platform is not Android,
+ * the function will do nothing and return a no-op unsubscribe function.
+ *
+ * @param {function(RecorderEvent): void} callback - Target callback function that will be invoked with
+ * the event data whenever the `noibuRecordingEvent` is emitted.
+ *
+ * @returns {UnsubscribeFn} Target function to unsubscribe from the event. On Android, this will remove
+ * the event listener. On other platforms, it will be a no-op.
+ *
+ * @throws {Error} If the Noibu Session Recorder is not initialized before calling this function.
+ */
+export declare function subscribeToNativeEvent(callback: (event: RecorderEvent) => void): UnsubscribeFn;

package/dist/sessionRecorder/types.d.ts

@@ -0,0 +1,91 @@
+type Color = {
+    a: number;
+    b: number;
+    r: number;
+    g: number;
+};
+type Paint = {
+    strokeJoin: number;
+    strokeWidth: number;
+    strokeCap: number;
+    color: Color;
+    dither: boolean;
+    blendMode: number;
+    style: number;
+    antiAlias: boolean;
+    strokeMiter: number;
+};
+type Rect = {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+};
+type Command = {
+    name?: string;
+    id?: number;
+    type: string;
+    isClipRectSource?: boolean;
+    rect?: Rect;
+    paintIndex?: number;
+    op?: number;
+    antiAlias?: boolean;
+    matrix?: number[];
+};
+type ViewNode = {
+    viewX: number;
+    visible: boolean;
+    processedText$delegate: {
+        _value: any;
+        initializer: any;
+    };
+    viewY: number;
+    viewWidth: number;
+    clickable: boolean;
+    viewHeight: number;
+    isMasked: boolean;
+    type: string;
+    renderNodeId: number;
+    isWebView: boolean;
+    ignoreClicks: boolean;
+    children: ViewNode[];
+    width: number;
+    x: number;
+    y: number;
+    id: number;
+    text: string;
+    height: number;
+    backgroundColor?: number;
+};
+type ViewHierarchy = {
+    root: ViewNode;
+    visibleFragments: any[];
+    timestamp: number;
+};
+type SubPicture = {
+    subPictures: any[];
+    images: any[];
+    screenWidth: number;
+    textBlobs: any[];
+    density: number;
+    vertices: any[];
+    screenHeight: number;
+    activityName: string;
+    paints: Paint[];
+    typefaces: any[];
+    viewHierarchy: ViewHierarchy;
+    paths: any[];
+    activityHashCode: number;
+    commands: Command[];
+    timestamp: number;
+};
+export type RecorderEvent = {
+    message: NativeFrames;
+};
+export type NativeFrames = {
+    p: (number | boolean | SubPicture)[][];
+    a: (number[] | (number | string | string[])[])[];
+    e: (string | number)[];
+};
+export type UnsubscribeFn = () => void;
+export {};

package/dist/storage/RNStorageProvider.d.ts

@@ -0,0 +1,19 @@
+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: Error | null;
+    }>;
+    /**
+     * Calculates used scape
+     * @returns {Number}
+     */
+    calculateUsedSize(): Promise<number>;
+}

package/dist/storage/Storage.d.ts

@@ -0,0 +1,29 @@
+import { Singleton } from '../monitors/BaseMonitor';
+/** Encapsulates storage api */
+export default class Storage extends Singleton implements IStorage {
+    private readonly isRNStorageAvailable;
+    private readonly rnStorageError;
+    private readonly provider;
+    private readonly type;
+    /** Creates new instance assessing available options */
+    constructor();
+    /** Checks if storage is available */
+    isAvailable(): Promise<boolean>;
+    /** Loads value from storage */
+    load(key: string): Promise<string | null>;
+    /** Saves value to storage */
+    save(key: string, value: 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/StorageProvider.d.ts

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

package/dist/types/NavigationIntegration.d.ts

@@ -0,0 +1,6 @@
+/**
+ * interface enforces constructor signature
+ */
+declare interface NavigationIntegration {
+    register(navigation: any, onNavigation: (breadcrumbs: string[]) => void): void;
+}

package/dist/utils/date.d.ts

@@ -0,0 +1,7 @@
+/** Checks to see if the necessary Date functions that we use have been overwritten */
+export declare function isDateOverwritten(): boolean;
+/** Timestamp wrapper to properly handle timestamps
+ */
+export declare function timestampWrapper<T>(timestamp: T): number | T;
+/** Get the current time in ISO format */
+export declare function getOccurredNow(): string;

package/dist/utils/date.js

@@ -1,5 +1,6 @@
 import ClientConfig from '../api/ClientConfig.js';
-import { SEVERITY } from '../constants.js';
+import '../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
+import { Severity } from '../node_modules/@noibu/metroplex-ts-bindings/dist/Severity.js';
 
 /** @module Date */
 /** Checks to see if the necessary Date functions that we use have been overwritten */
@@ -39,7 +40,7 @@ function timestampWrapper(timestamp) {
         ClientConfig.getInstance().postInternalError({
             msg: `The date object has been overwritten and can't be processed properly.
       Client has been disabled.`,
-        }, true, SEVERITY.error, true);
+        }, true, Severity.ERROR, true);
     }
     return timestamp;
 }

package/dist/utils/eventlistener.d.ts

@@ -0,0 +1,8 @@
+/** 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
+ */
+export function addSafeEventListener(object: any, event: any, callback: any, capture?: any): void;