noibu-react-native 0.1.1 → 0.1.2

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