noibu-react-native 0.2.7 → 0.2.8

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.8",
   "targetNjsVersion": "1.0.104",
   "description": "React-Native SDK for NoibuJS to collect errors in React-Native applications",
   "main": "dist/entry/index.js",
@@ -49,7 +49,7 @@
     "@babel/preset-typescript": "^7.26.0",
     "@eslint/eslintrc": "^3.2.0",
     "@jest/globals": "^29.7.0",
-    "@noibu/metroplex-ts-bindings": "1.0.24",
+    "@noibu/metroplex-ts-bindings": "1.0.25",
     "@react-native-async-storage/async-storage": "^1.19.0",
     "@rollup/plugin-commonjs": "^25.0.0",
     "@rollup/plugin-json": "^6.0.0",