noibu-react-native 0.1.1 → 0.1.3

package/dist/utils/function.js

@@ -1,8 +1,9 @@
-import DeviceInfo from 'react-native-device-info';
+import { Platform } from 'react-native';
 import { parseStack } from './stacktrace-parser.js';
 import { MAX_STRING_LENGTH, MAX_BEACON_PAYLOAD_SIZE, REQUIRED_DATA_PROCESSING_URLS, PII_EMAIL_PATTERN, PII_REDACTION_REPLACEMENT_STRING, PII_DIGIT_PATTERN, DEFAULT_STACK_FRAME_FIELD_VALUE } from '../constants.js';
+import { noibuLog } from './log.js';
+import { unwrapNoibuWrapped } from './object.js';
 
-/** @module Functions */
 /**
  * Returns a stack trace frame with default filed values
  */
@@ -139,7 +140,7 @@ async function makeRequest(method, url, data, headers, timeout, sendAndForget) {
         if (currentPayloadSize > MAX_BEACON_PAYLOAD_SIZE) {
             return Promise.resolve();
         }
-        return fetch(url, {
+        return unwrapNoibuWrapped(fetch)(url, {
             method: 'POST',
             headers: headersWithUa,
             body: stringifyJSON(data),
@@ -186,20 +187,22 @@ function isValidURL(str) {
 }
 let userAgentCache = '';
 /**
- * Because of the nature of user agent in react native, we have to make this async.
- * But I promise, this is really fast, since we memoize the result for the whole session :)
- * @returns {Promise<string>}
+ * Fakes the user agent retrieval, since there are no good libraries that support both expo and plain RN
+ * caches the result for the session
  */
 async function getUserAgent() {
     if (userAgentCache) {
         return userAgentCache;
     }
-    try {
-        userAgentCache = await DeviceInfo.getUserAgent();
+    noibuLog('getUserAgent start');
+    if (Platform.OS === 'android') {
+        const { Brand, Model, Release } = Platform.constants;
+        userAgentCache = `Mozilla/5.0 (Linux; Android ${Release}; ${Brand} ${Model}; React Native ${Platform.Version}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Mobile Safari/537.36`;
     }
-    catch (e) {
-        userAgentCache = '';
+    else if (Platform.OS === 'ios') {
+        userAgentCache = `Mozilla/5.0 (iPhone; CPU iPhone OS ${Platform.constants.osVersion} like Mac OS X; React Native ${Platform.Version}) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.0.1 Mobile/15E148 Safari/604.1`;
     }
+    noibuLog('getUserAgent end', { userAgentCache });
     return userAgentCache;
 }
 /**
@@ -210,6 +213,7 @@ function isInvalidURLConfig(urls) {
     for (let i = 0; i < REQUIRED_DATA_PROCESSING_URLS.length; i += 1) {
         const u = REQUIRED_DATA_PROCESSING_URLS[i];
         if (!urls[u]) {
+            noibuLog('urlConfig invalid, reason', u);
             return true;
         }
     }
@@ -224,6 +228,7 @@ function isNoibuJSAlreadyLoaded() {
     const loaded = window.noibuJSLoaded !== undefined;
     // set the variable so future copies of the script
     // will know this instance is running
+    noibuLog('is already loaded? -', loaded);
     window.noibuJSLoaded = true;
     return loaded;
 }

package/dist/utils/log.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react-native" />
+/**
+ * log with level = info
+ */
+export declare const noibuLog: Console['log'];

package/dist/utils/log.js

@@ -0,0 +1,17 @@
+/* eslint-disable no-console,@typescript-eslint/no-empty-function */
+/** no operation */
+const noop = () => { };
+/**
+ * checks if was overridden and calls original console function
+ */
+const getConsoleMethod = (ogProp) => {
+    {
+        return noop;
+    }
+};
+/**
+ * log with level = info
+ */
+const noibuLog = (...msgs) => getConsoleMethod()('Noibu', ...msgs);
+
+export { noibuLog };

package/dist/utils/object.d.ts

@@ -0,0 +1,41 @@
+/** @module Object */
+type Func = (...args: any[]) => any;
+/**
+ * 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
+ * @param  {} sourceObject
+ * @param  {} attributeName
+ * @param  {} processingFunction
+ */
+export declare const replace: <A extends { [k in K]: Func; }, K extends keyof A>(sourceObject: A, attributeName: K, processingFunction: (arg: A[K]) => A[K]) => void;
+/**
+ * unwraps wrapped property, so we can use it without side effects
+ * @param anything
+ */
+export declare function unwrapNoibuWrapped<T>(anything: {
+    __noibu_original__?: T;
+} & T): NonNullable<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.
+ * @param {object} proto
+ * @param {string} property
+ * @returns {boolean} Whether the property on the prototype is (or is now) writeable
+ */
+export declare const propWriteableOrMadeWriteable: (proto: object, property: never) => 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 A 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: Record<any, any>, p: any, v: any) => any, limit?: {
+    depth: number;
+}) => void;
+export {};

package/dist/utils/object.js

@@ -10,39 +10,43 @@
  * @param  {} processingFunction
  */
 const replace = (sourceObject, attributeName, processingFunction) => {
-  if (!(attributeName in sourceObject)) {
-    return;
-  }
-
-  const originalAttribute = sourceObject[attributeName];
-  const newValue = processingFunction(originalAttribute);
-
-  if (typeof newValue === 'function') {
-    try {
-      newValue.prototype = newValue.prototype || {};
-      Object.defineProperties(newValue, {
-        __noibu__: {
-          enumerable: false,
-          value: true,
-        },
-        __noibu_original__: {
-          enumerable: false,
-          value: originalAttribute,
-        },
-        __noibu_wrapped__: {
-          enumerable: false,
-          value: newValue,
-        },
-      });
-    } catch (err) {
-      // silent fail
+    if (!(attributeName in sourceObject)) {
+        return;
     }
-  }
-
-  // eslint-disable-next-line no-param-reassign
-  sourceObject[attributeName] = newValue;
+    const originalAttribute = sourceObject[attributeName];
+    const newValue = processingFunction(originalAttribute);
+    if (typeof newValue === 'function') {
+        try {
+            newValue.prototype = newValue.prototype || {};
+            Object.defineProperties(newValue, {
+                __noibu__: {
+                    enumerable: false,
+                    value: true,
+                },
+                __noibu_original__: {
+                    enumerable: false,
+                    value: originalAttribute,
+                },
+                __noibu_wrapped__: {
+                    enumerable: false,
+                    value: newValue,
+                },
+            });
+        }
+        catch (err) {
+            // silent fail
+        }
+    }
+    // eslint-disable-next-line no-param-reassign
+    sourceObject[attributeName] = newValue;
 };
-
+/**
+ * unwraps wrapped property, so we can use it without side effects
+ * @param anything
+ */
+function unwrapNoibuWrapped(anything) {
+    return anything.__noibu_original__ || anything;
+}
 /**
  * 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
@@ -52,50 +56,29 @@ const replace = (sourceObject, attributeName, processingFunction) => {
  * @returns {boolean} Whether the property on the prototype is (or is now) writeable
  */
 const propWriteableOrMadeWriteable = (proto, property) => {
-  if (
-    !proto ||
-    !proto.hasOwnProperty ||
-    !Object.prototype.hasOwnProperty.call(proto, property)
-  ) {
-    return false;
-  }
-
-  // Getting the properties that this the prototype
-  // has under the open property
-  const propDescriptor = Object.getOwnPropertyDescriptor(proto, property);
-
-  // Checking if the open property is read-only
-  if (!propDescriptor.writable) {
-    // Checking if we can write to it
-    if (propDescriptor.configurable) {
-      // Making it writable to wrap it
-      Object.defineProperty(proto, property, {
-        writable: true,
-      });
-    } else {
-      return false;
+    if (!proto ||
+        !proto.hasOwnProperty ||
+        !Object.prototype.hasOwnProperty.call(proto, property)) {
+        return false;
     }
-  }
-  return true;
-};
-
-/**
- * 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
- */
-const safeFromEntries = entries => {
-  if (!entries || !entries[Symbol.iterator]) {
-    throw new Error('Object.fromEntries() requires a single iterable argument');
-  }
-  const obj = {};
-  // eslint-disable-next-line no-restricted-syntax
-  for (const [key, value] of entries) {
-    obj[key] = value;
-  }
-  return obj;
+    // Getting the properties that this the prototype
+    // has under the open property
+    const propDescriptor = Object.getOwnPropertyDescriptor(proto, property);
+    // Checking if the open property is read-only
+    if (!propDescriptor?.writable) {
+        // Checking if we can write to it
+        if (propDescriptor?.configurable) {
+            // Making it writable to wrap it
+            Object.defineProperty(proto, property, {
+                writable: true,
+            });
+        }
+        else {
+            return false;
+        }
+    }
+    return true;
 };
-
 /**
  * Iterates object recursively and calls visit function
  * for each property allowing to override its value
@@ -104,41 +87,35 @@ const safeFromEntries = entries => {
  * 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
  */
-const iterateObjectRecursively = (
-  instance,
-  visit,
-  limit = { depth: 5 },
-) => {
-  /* eslint-disable no-shadow, no-restricted-syntax, no-param-reassign, guard-for-in */
-  /**
-   * internal recursive function
-   * @param {Object} instance Current object
-   * @param {Number} depth Current depth
-   */
-  const iterate = (instance, depth) => {
-    // stop to go deeper if it is deep enough already
-    if (depth > limit.depth) return;
-    for (const property in instance) {
-      try {
-        // call visit function and assign its result if not undefined
-        const newValue = visit(instance, property, instance[property]);
-        if (newValue !== undefined) {
-          instance[property] = newValue;
-        }
-        // go one level deeper if it is an object
-        if (
-          instance[property] !== null &&
-          typeof instance[property] === 'object'
-        ) {
-          iterate(instance[property], depth + 1);
+const iterateObjectRecursively = (instance, visit, limit = { depth: 5 }) => {
+    /* eslint-disable no-shadow, no-restricted-syntax, no-param-reassign, guard-for-in */
+    /**
+     * internal recursive function
+     * @param {Object} inst Current object
+     * @param {Number} depth Current depth
+     */
+    const iterate = (inst, depth) => {
+        // stop to go deeper if it is deep enough already
+        if (depth > limit.depth)
+            return;
+        for (const property in inst) {
+            try {
+                // call visit function and assign its result if not undefined
+                const newValue = visit(inst, property, inst[property]);
+                if (newValue !== undefined) {
+                    inst[property] = newValue;
+                }
+                // go one level deeper if it is an object
+                if (inst[property] !== null && typeof inst[property] === 'object') {
+                    iterate(inst[property], depth + 1);
+                }
+            }
+            catch (e) {
+                // just continue to the next property
+            }
         }
-      } catch (e) {
-        // just continue to the next property
-      }
-    }
-  };
-
-  iterate(instance, 1);
+    };
+    iterate(instance, 1);
 };
 
-export { iterateObjectRecursively, propWriteableOrMadeWriteable, replace, safeFromEntries };
+export { iterateObjectRecursively, propWriteableOrMadeWriteable, replace, unwrapNoibuWrapped };

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(): any;

package/dist/utils/performance.js

@@ -1,14 +1,13 @@
 import { timestampWrapper } from './date.js';
 
 /** @module Performance */
-
 /**
  * Wrapper function for window.performance.now() to ensure
  * it's available before calling it. If it's not available,
  * we return Date.now() instead.
  */
 function safePerformanceNow() {
-  return timestampWrapper(Date.now());
+    return timestampWrapper(Date.now());
 }
 
 export { safePerformanceNow };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "noibu-react-native",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "targetNjsVersion": "1.0.104",
   "description": "React-Native SDK for NoibuJS to collect errors in React-Native applications",
   "main": "dist/entry/index.js",
@@ -21,14 +21,15 @@
     "lint_output": "eslint src -c .eslintrc.json --ext js,ts,jsx,tsx -f json > eslint_report.json",
     "codecov": "codecov"
   },
-  "optionalDependencies": {
-    "react-native-navigation": "7"
+  "peerDependenciesMeta": {
+    "react-native-navigation": {
+      "optional": true
+    }
   },
   "dependencies": {
     "@react-native-async-storage/async-storage": "^1.19.0",
     "react": ">=16.11.0",
     "react-native": ">=0.63.0",
-    "react-native-device-info": "^10.6.0",
     "react-native-url-polyfill": "^1.3.0",
     "react-native-uuid": "^2.0.1"
   },

package/dist/pageVisit/pageVisitEventError/blacklistedDomains.js

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