noibu-react-native 0.0.9 → 0.1.2

package/dist/utils/function.js

@@ -1,6 +1,8 @@
 import DeviceInfo from 'react-native-device-info';
 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 */
 /**
@@ -41,6 +43,10 @@ function processFrames(rawFrames) {
         }
         if (frame.file && frame.file !== '<unknown>') {
             processedFrame.file = String(frame.file);
+            if (isValidURL(processedFrame.file)) {
+                // todo remove comment if assumption that react native only has local urls in filenames is correct
+                processedFrame.file = new URL(processedFrame.file).pathname;
+            }
         }
         if (frame.column) {
             if (Number.isInteger(frame.column)) {
@@ -135,7 +141,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),
@@ -206,6 +212,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;
         }
     }
@@ -220,6 +227,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,15 @@
+/* eslint-disable no-console,@typescript-eslint/no-empty-function */
+/** no operation */
+/**
+ * checks if was overridden and calls original console function
+ */
+const getConsoleMethod = (ogProp) => {
+    // @ts-ignore
+    return console[ogProp].__noibu_original__ || console[ogProp];
+};
+/**
+ * log with level = info
+ */
+const noibuLog = (...msgs) => getConsoleMethod('log')('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/dist/utils/stacktrace-parser.js

@@ -88,50 +88,6 @@ const chrome = (line) => {
     }
     return undefined;
 };
-const geckoREgex = /^\s*(.*?)(?:\((.*?)\))?(?:^|@)?((?:[-a-z]+)?:\/.*?|\[native code\]|[^@]*(?:bundle|\d+\.js)|\/[\w\-. /=]+)(?::(\d+))?(?::(\d+))?\s*$/i;
-const geckoEvalRegex = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i;
-const gecko = (line) => {
-    const parts = geckoREgex.exec(line);
-    if (parts) {
-        const isEval = parts[3] && parts[3].indexOf(' > eval') > -1;
-        if (isEval) {
-            const subMatch = geckoEvalRegex.exec(parts[3]);
-            if (subMatch) {
-                // throw out eval line/column and use top-most line number
-                parts[1] = parts[1] || 'eval';
-                parts[3] = subMatch[1];
-                parts[4] = subMatch[2];
-                parts[5] = ''; // no column when eval
-            }
-        }
-        let filename = parts[3];
-        let func = parts[1] || UNKNOWN_FUNCTION;
-        [func, filename] = extractSafariExtensionDetails(func, filename);
-        return createFrame(filename, func, parts[4] ? +parts[4] : undefined, parts[5] ? +parts[5] : undefined);
-    }
-    return undefined;
-};
-const winjsRegex = /^\s*at (?:((?:\[object object\])?.+) )?\(?((?:[-a-z]+):.*?):(\d+)(?::(\d+))?\)?\s*$/i;
-const winjs = (line) => {
-    const parts = winjsRegex.exec(line);
-    return parts
-        ? createFrame(parts[2], parts[1] || UNKNOWN_FUNCTION, +parts[3], parts[4] ? +parts[4] : undefined)
-        : undefined;
-};
-const opera10Regex = / line (\d+).*script (?:in )?(\S+)(?:: in function (\S+))?$/i;
-const opera10 = (line) => {
-    const parts = opera10Regex.exec(line);
-    return parts
-        ? createFrame(parts[2], parts[3] || UNKNOWN_FUNCTION, +parts[1])
-        : undefined;
-};
-const opera11Regex = / line (\d+), column (\d+)\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\(.*\))? in (.*):\s*$/i;
-const opera11 = (line) => {
-    const parts = opera11Regex.exec(line);
-    return parts
-        ? createFrame(parts[5], parts[3] || parts[4] || UNKNOWN_FUNCTION, +parts[1], +parts[2])
-        : undefined;
-};
 function parseStack(stackString) {
     const lines = stackString.split('\n');
     if (lines.length > MAX_FRAMES_IN_ARRAY) {
@@ -141,11 +97,7 @@ function parseStack(stackString) {
         if (line.length > MAX_STRING_LENGTH) {
             return stack;
         }
-        const parseResult = gecko(line) ||
-            chrome(line) ||
-            winjs(line) ||
-            opera11(line) ||
-            opera10(line);
+        const parseResult = chrome(line);
         if (parseResult) {
             stack.push(parseResult);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "noibu-react-native",
-  "version": "0.0.9",
+  "version": "0.1.2",
   "targetNjsVersion": "1.0.104",
   "description": "React-Native SDK for NoibuJS to collect errors in React-Native applications",
   "main": "dist/entry/index.js",

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 };