noibu-react-native 0.2.7 → 0.2.9

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,5 @@
 import ClientConfig from '../api/ClientConfig.js';
-import { SEVERITY } from '../constants.js';
+import { Severity } from 'noibu-metroplex-ts-bindings';
 
 /** @module Date */
 /** Checks to see if the necessary Date functions that we use have been overwritten */
@@ -39,7 +39,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;

package/dist/utils/eventlistener.js

@@ -1,4 +1,3 @@
-import { SEVERITY } from '../constants.js';
 import ClientConfig from '../api/ClientConfig.js';
 
 /** addSafeEventListener will add an event listener for the specified event
@@ -24,7 +23,7 @@ function addSafeEventListener(object, event, callback, capture = false) {
       ClientConfig.getInstance().postInternalError(
         `addEventListener callback error: ${e.message}`,
         false,
-        SEVERITY.error,
+        Severity.ERROR,
       );
     }
   };
@@ -53,7 +52,7 @@ function addSafeEventListener(object, event, callback, capture = false) {
         return;
       }
     }
-    ClientConfig.getInstance().postInternalError(`addEventListener error: ${e.message}`, false, SEVERITY.error);
+    ClientConfig.getInstance().postInternalError(`addEventListener error: ${e.message}`, false, Severity.ERROR);
   }
 }
 

package/dist/utils/function.d.ts

@@ -0,0 +1,72 @@
+import { JSError } from 'noibu-metroplex-ts-bindings';
+import { RawStackFrame } from './stacktrace-parser';
+/**
+ * returns a string that satisfies a max length
+ * stringToVerify: string that needs to be verified
+ * length :optional, max length that stringToVerify can be
+ */
+export declare function getMaxSubstringAllowed(stringToVerify: string, length?: number): string;
+/**
+ * Processes the raw stack frames and creates a readable stack in a safe manner
+ */
+export declare function processFrames(rawFrames: RawStackFrame[]): import("noibu-metroplex-ts-bindings").JSStackFrame[];
+/** Retrieves the javascript stack and message from an error event object */
+export declare function getJSStack(errObj?: {
+    stack?: string | NativeStackAndroid;
+    message?: string;
+}): JSError;
+/**
+ * Checks if possiblyStacktrace has any stack frames present
+ */
+export declare function isStackTrace(_possiblyStacktrace: unknown): _possiblyStacktrace is string;
+/**
+ * counts the number of bytes
+ */
+export declare function byteCount(s: string): number;
+/**
+ * Stringify function that is aware of inner circular references and handles them by replacing with {} (empty object)
+ * taken from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Cyclic_object_value
+ */
+export declare function stringifyJSON(jsonObject: unknown): string;
+/**
+ * Wrapper for a request with an ability to send-and-forget
+ * a send-and-forget request can outlive the page
+ */
+export declare function postRequest(url: string | URL, data: unknown, headers: Record<string, string>, sendAndForget?: boolean, timeout?: number): Promise<void>;
+/**
+ * makes sure the url sent is a valid URL
+ */
+export declare function isValidURL(str: string): boolean;
+/**
+ * Fakes the user agent retrieval, since there are no good libraries that support both expo and plain RN
+ * caches the result for the session
+ */
+export declare function getUserAgent(): Promise<string>;
+/**
+ * isNoibuJSAlreadyLoaded will verify if there are already other
+ * copies of NoibuJS runnung
+ */
+export declare function isNoibuJSAlreadyLoaded(): boolean;
+/**
+ * asString will create a string out of anything passed to it.
+ */
+export declare function asString(obj: unknown): string;
+/**
+ * masks textual content if it ressembles something sensitive
+ */
+export declare function maskTextInput(text: string): string;
+/**
+ * Checks if the provided object is an instance of the specified type.
+ * It's safer than `instanceof` operator as it handles cases
+ * where type is not actually a type but an object.
+ */
+export declare function isInstanceOf<T>(instance: unknown, type: T): instance is T;
+/** String.trim, but safe */
+export declare function safeTrim(text: unknown): string;
+/**
+ * Tries to get the stack trace from the given error object and returns it.
+ * If the error object does not have a stack trace, an empty string is returned.
+ */
+export declare function tryGetStackTrace(error: {
+    stack?: string;
+}): string;

package/dist/utils/log.d.ts

@@ -0,0 +1,4 @@
+/**log with level = info */
+export declare const noibuLog: Console['log'];
+/**log with level = error */
+export declare const noibuErr: Console['error'];

package/dist/utils/log.js

@@ -9,7 +9,5 @@ const getConsoleMethod = (ogProp) => {
 };
 /**log with level = info */
 const noibuLog = (...msgs) => getConsoleMethod('log')('Noibu', ...msgs);
-/**log with level = error */
-const noibuErr = (...msgs) => getConsoleMethod('error')('Noibu', ...msgs);
 
-export { noibuErr, noibuLog };
+export { noibuLog };

package/dist/utils/object.d.ts

@@ -0,0 +1,46 @@
+/** @module Object */
+/**
+ * Replaces an attribute value found in an object with another value
+ * sourceObject: source object whose attribute will get replaced
+ * attributeName: the attribute key whose value will be replace
+ * processingFunction: function that accepts the original value
+ * and returns the newValue
+ */
+export declare function replace<Target extends object, Prop extends keyof Target>(sourceObject: Target, attributeName: Prop, processingFunction: (arg: Target[Prop]) => Target[Prop]): void;
+/**
+ * unwraps wrapped property, so we can use it without side effects
+ */
+export declare function unwrapNoibuWrapped<T>(anything: {
+    __noibu_original__?: T;
+} & T): NonNullable<T>;
+/**
+ * Checks if the given object is wrapped
+ */
+export declare function isNoibuWrapped<T extends object>(anything: T): anything is {
+    __noibu_original__?: T;
+} & T;
+/**
+ * Checks whether the prototype's property is writeable. If it is not,
+ * checks whether the property can be made writeable. If it can, it is
+ * set to writeable.
+ * returns Whether the property on the prototype is (or is now) writeable
+ */
+export declare const propWriteableOrMadeWriteable: <T>(proto: T, property: keyof T) => boolean;
+/**
+ * Iterates object recursively and calls visit function
+ * for each property allowing to override its value
+ * @param {Object} instance An object to iterate through
+ * @param {Function} visit Target callback function that is called for each property
+ * There are 3 arguments: current object, current property and its value
+ * @param {{depth: number}} limit Use limit config object to set depth of the recursion
+ */
+export declare const iterateObjectRecursively: (instance: Record<any, any>, visit: (i: typeof instance, p: keyof typeof i, v: (typeof i)[typeof p]) => typeof v, limit?: {
+    depth: number;
+}) => void;
+export declare const safeEntries: (obj: unknown | Record<string, string | null> | Headers) => [string, string | null][];
+/**
+ * Replaces the behaviour of Object.fromEntries() as it is not supported on all browsers
+ * @param {Iterable} entries The iterable to parse into an object
+ * @returns An object containing the same key/values as the iterable passed
+ */
+export declare const safeFromEntries: <T>(entries: unknown) => Record<string, T>;

package/dist/utils/performance.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Wrapper function for window.performance.now() to ensure
+ * it's available before calling it. If it's not available,
+ * we return Date.now() instead.
+ */
+export declare function safePerformanceNow(): number;

package/dist/utils/piiRedactor.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Redacts one string, returns redacted value or false if nothing to redact
+ */
+export declare function shouldRedact(field: string): boolean;
+/**
+ * Takes a string and redacts any PII we're able to detect
+ *
+ * content - the string from which we want to redact PII
+ * returns the string with any PII we're able to detect redacted.
+ */
+export declare function removePII(content: string): string;

package/dist/utils/polyfills.d.ts

@@ -0,0 +1,4 @@
+/**
+ * In case Promise.all is not available, use this polyfill
+ */
+export declare const promiseAll: any;

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

@@ -0,0 +1,8 @@
+export declare const MAX_FRAMES_IN_ARRAY = 15;
+export declare interface RawStackFrame {
+    file: string;
+    line?: number;
+    column?: number;
+    mname: string;
+}
+export declare function parseStack(stackString: string | NativeStackAndroid): RawStackFrame[];

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

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "noibu-react-native",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "targetNjsVersion": "1.0.104",
   "description": "React-Native SDK for NoibuJS to collect errors in React-Native applications",
   "main": "dist/entry/index.js",
@@ -26,6 +26,9 @@
       "optional": true
     }
   },
+  "dependencies": {
+    "noibu-metroplex-ts-bindings": "1.0.27"
+  },
   "optionalDependencies": {
     "@react-native-async-storage/async-storage": "^1.19.0",
     "fflate": "^0.8.2",
@@ -49,7 +52,6 @@
     "@babel/preset-typescript": "^7.26.0",
     "@eslint/eslintrc": "^3.2.0",
     "@jest/globals": "^29.7.0",
-    "@noibu/metroplex-ts-bindings": "1.0.24",
     "@react-native-async-storage/async-storage": "^1.19.0",
     "@rollup/plugin-commonjs": "^25.0.0",
     "@rollup/plugin-json": "^6.0.0",