noibu-react-native 0.2.6 → 0.2.8

package/dist/utils/date.js

@@ -1,62 +1,52 @@
-import ClientConfig from '../api/clientConfig.js';
-import { SEVERITY } from '../constants.js';
+import ClientConfig from '../api/ClientConfig.js';
+import '../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
+import { Severity } from '../node_modules/@noibu/metroplex-ts-bindings/dist/Severity.js';
 
 /** @module Date */
-
 /** Checks to see if the necessary Date functions that we use have been overwritten */
 function isDateOverwritten() {
-  // Check to see if Date.now() exists
-  if (!('now' in Date)) {
-    return true;
-  }
-
-  // Check to ensure that Date.now() returns a number
-  if (typeof Date.now() !== 'number') {
-    return true;
-  }
-
-  // Check to see if new Date().toISOString() exists
-  if (!('toISOString' in new Date())) {
-    return true;
-  }
-
-  // Check to ensure new Date().toISOString() returns a string
-  if (typeof new Date().toISOString() !== 'string') {
-    return true;
-  }
-
-  // If none of the above checks return true, we assume that the Date function
-  // has not been overwritten
-  return false;
+    // Check to see if Date.now() exists
+    if (!('now' in Date)) {
+        return true;
+    }
+    // Check to ensure that Date.now() returns a number
+    if (typeof Date.now() !== 'number') {
+        return true;
+    }
+    // Check to see if new Date().toISOString() exists
+    if (!('toISOString' in new Date())) {
+        return true;
+    }
+    // Check to ensure new Date().toISOString() returns a string
+    if (typeof new Date().toISOString() !== 'string') {
+        return true;
+    }
+    // If none of the above checks return true, we assume that the Date function
+    // has not been overwritten
+    return false;
 }
-
 /** Timestamp wrapper to properly handle timestamps
- * @param  {} timestamp
  */
 function timestampWrapper(timestamp) {
-  // If the Date object has been overwritten and the timestamp is not a number,
-  // we use the valueOf property to try to retrieve the actual timestamp.
-  // If valueOf is not available, we disable client and log the error.
-  if (typeof timestamp !== 'number' && isDateOverwritten()) {
-    if (
-      // eslint-disable-next-line no-prototype-builtins
-      Date.prototype.hasOwnProperty('valueOf') &&
-      typeof timestamp.valueOf === 'function' &&
-      typeof timestamp.valueOf() === 'number'
-    ) {
-      return timestamp.valueOf();
-    }
-
-    ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(
-      `The date object has been overwritten and can't be processed properly.
+    var _a;
+    // If the Date object has been overwritten and the timestamp is not a number,
+    // we use the valueOf property to try to retrieve the actual timestamp.
+    // If valueOf is not available, we disable client and log the error.
+    if (typeof timestamp === 'object' && isDateOverwritten()) {
+        const value = (_a = timestamp === null || timestamp === void 0 ? void 0 : timestamp.valueOf) === null || _a === void 0 ? void 0 : _a.call(timestamp);
+        if (typeof value === 'number') {
+            return value;
+        }
+        ClientConfig.getInstance().postInternalError({
+            msg: `The date object has been overwritten and can't be processed properly.
       Client has been disabled.`,
-      true,
-      SEVERITY.error,
-      true,
-    );
-  }
-
-  return timestamp;
+        }, true, Severity.ERROR, true);
+    }
+    return timestamp;
+}
+/** Get the current time in ISO format */
+function getOccurredNow() {
+    return new Date(timestampWrapper(Date.now())).toISOString();
 }
 
-export { isDateOverwritten, timestampWrapper };
+export { getOccurredNow, isDateOverwritten, timestampWrapper };

package/dist/utils/eventlistener.js

@@ -1,5 +1,4 @@
-import { SEVERITY } from '../constants.js';
-import ClientConfig from '../api/clientConfig.js';
+import ClientConfig from '../api/ClientConfig.js';
 
 /** addSafeEventListener will add an event listener for the specified event
  * but will catch and log any errors encountered
@@ -21,25 +20,22 @@ function addSafeEventListener(object, event, callback, capture = false) {
     try {
       callback(eventReceived);
     } catch (e) {
-      ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(
+      ClientConfig.getInstance().postInternalError(
         `addEventListener callback error: ${e.message}`,
         false,
-        SEVERITY.error,
+        Severity.ERROR,
       );
     }
   };
 
-  /**
-   * tries to add an event listener to a Proxy object
-   */
+  /** tries to add an event listener to a Proxy object */
   const tryAddEventListenerForProxy = () => {
     if (!Reflect) {
       return false;
     }
 
     try {
-      const addEventListener =
-        Reflect.get(object, 'addEventListener') || (() => {});
+      const addEventListener = Reflect.get(object, 'addEventListener') || (() => {});
       addEventListener(event, safeCallback, capture);
     } catch (e) {
       return false;
@@ -56,11 +52,7 @@ function addSafeEventListener(object, event, callback, capture = false) {
         return;
       }
     }
-    ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(
-      `addEventListener error: ${e.message}`,
-      false,
-      SEVERITY.error,
-    );
+    ClientConfig.getInstance().postInternalError(`addEventListener error: ${e.message}`, false, Severity.ERROR);
   }
 }
 

package/dist/{src/utils → utils}/function.d.ts

@@ -1,6 +1,5 @@
+import { JSError } from '@noibu/metroplex-ts-bindings';
 import { RawStackFrame } from './stacktrace-parser';
-import { REQUIRED_DATA_PROCESSING_URLS } from '../constants';
-import { JSErrorOutputMessage } from '../../types/PageVisitErrors.types';
 /**
  * returns a string that satisfies a max length
  * stringToVerify: string that needs to be verified
@@ -10,20 +9,12 @@ export declare function getMaxSubstringAllowed(stringToVerify: string, length?:
 /**
  * Processes the raw stack frames and creates a readable stack in a safe manner
  */
-export declare function processFrames(rawFrames: RawStackFrame[]): {
-    file: string;
-    line: string;
-    mname: string;
-    column?: number;
-}[];
-/**
- * Retrieves the javascript stack and message from an error event object
- * @param errObj error to extract stack from
- */
-export declare function getJSStack(errObj: {
-    stack: string;
-    message: string;
-}): JSErrorOutputMessage;
+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
  */
@@ -38,15 +29,10 @@ export declare function byteCount(s: string): number;
  */
 export declare function stringifyJSON(jsonObject: unknown): string;
 /**
- * Wrapper for a request, since we have to do some special handling
- * @param method
- * @param url
- * @param data
- * @param headers
- * @param timeout
- * @param sendAndForget
+ * Wrapper for a request with an ability to send-and-forget
+ * a send-and-forget request can outlive the page
  */
-export declare function makeRequest(method: string, url: string, data: unknown, headers: Record<string, string>, timeout: number, sendAndForget: boolean): Promise<unknown>;
+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
  */
@@ -56,11 +42,6 @@ export declare function isValidURL(str: string): boolean;
  * caches the result for the session
  */
 export declare function getUserAgent(): Promise<string>;
-/**
- * isInvalidURLConfig will verify that Collect is being initializes with
- * the correct env vars.
- */
-export declare function isInvalidURLConfig(urls: Record<(typeof REQUIRED_DATA_PROCESSING_URLS)[number], string>): boolean;
 /**
  * isNoibuJSAlreadyLoaded will verify if there are already other
  * copies of NoibuJS runnung
@@ -80,23 +61,12 @@ export declare function maskTextInput(text: string): string;
  * where type is not actually a type but an object.
  */
 export declare function isInstanceOf<T>(instance: unknown, type: T): instance is T;
-/**
- * To grab the video recorder type based on the device we run the app on.
- */
-export declare function getVideoRecorderType(): Promise<string>;
 /** 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.
- *
- * @param {Error} error - The error object from which to retrieve the stack trace.
- * @returns {string} The stack trace of the error, if available. Otherwise, an empty string is returned.
- */
-export declare function tryGetStackTrace(error: any): string;
-/**
- * Checks whether the given value is a string or an instance of String.
- * @param {*} value - The value to be checked.
- * @returns {boolean} Returns true if the value is a string or an instance of String, otherwise returns false.
  */
-export declare function isString(value: any): value is string | String;
+export declare function tryGetStackTrace(error: {
+    stack?: string;
+}): string;

package/dist/utils/function.js

@@ -1,17 +1,21 @@
 import { __awaiter } from 'tslib';
 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, JS_STACK_LINE_ATT_NAME, DEFAULT_STACK_FRAME_FIELD_VALUE, JS_STACK_METHOD_ATT_NAME, JS_STACK_FILE_ATT_NAME } from '../constants.js';
+import { MAX_STRING_LENGTH, MAX_BEACON_PAYLOAD_SIZE, PII_EMAIL_PATTERN, PII_REDACTION_REPLACEMENT_STRING } from '../constants.js';
 import { noibuLog } from './log.js';
 import { unwrapNoibuWrapped } from './object.js';
 
+// default string for stack frame fields
+const DEFAULT_STACK_FRAME_FIELD_VALUE = '_';
+const PII_DIGIT_PATTERN = /[0-9]+/g;
+const STACK_TRACE_SANITIZE_REGEXP = /(nbuGlobalPromiseRejectWrapper|InternalBytecode)/gi;
 /**
  * Returns a stack trace frame with default filed values
  */
 const getDefaultFrame = () => ({
-    [JS_STACK_LINE_ATT_NAME]: DEFAULT_STACK_FRAME_FIELD_VALUE,
-    [JS_STACK_METHOD_ATT_NAME]: DEFAULT_STACK_FRAME_FIELD_VALUE,
-    [JS_STACK_FILE_ATT_NAME]: DEFAULT_STACK_FRAME_FIELD_VALUE,
+    line: DEFAULT_STACK_FRAME_FIELD_VALUE,
+    mname: DEFAULT_STACK_FRAME_FIELD_VALUE,
+    file: DEFAULT_STACK_FRAME_FIELD_VALUE,
 });
 /**
  * returns a string that satisfies a max length
@@ -55,22 +59,15 @@ function processFrames(rawFrames) {
         return processedFrame;
     });
 }
-/**
- * Retrieves the javascript stack and message from an error event object
- * @param errObj error to extract stack from
- */
+/** Retrieves the javascript stack and message from an error event object */
 function getJSStack(errObj) {
-    let frames = [getDefaultFrame()];
     // if the errObj type is not an object or null
     // return a default frame
     if (typeof errObj !== 'object' || !errObj || !errObj.stack) {
-        return {
-            frames,
-            msg: '',
-        };
+        return { frames: [getDefaultFrame()], msg: '' };
     }
-    frames = processFrames(parseStack(errObj.stack));
     const msg = errObj.message ? getMaxSubstringAllowed(errObj.message) : '';
+    const frames = processFrames(parseStack(errObj.stack)).filter(line => !`${line.file}|${line.mname}`.match(STACK_TRACE_SANITIZE_REGEXP));
     return {
         frames,
         msg,
@@ -111,63 +108,36 @@ function stringifyJSON(jsonObject) {
     });
 }
 /**
- * Wrapper for a request, since we have to do some special handling
- * @param method
- * @param url
- * @param data
- * @param headers
- * @param timeout
- * @param sendAndForget
+ * Wrapper for a request with an ability to send-and-forget
+ * a send-and-forget request can outlive the page
  */
-function makeRequest(method, url, data, headers, timeout, sendAndForget) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const ua = Object.keys(headers).findLast(k => k.toLowerCase() === 'user-agent');
-        const headersWithUa = Object.assign({}, headers);
-        if (!headers[ua]) {
-            headersWithUa['User-Agent'] = yield getUserAgent();
-        }
-        // a send-and-forget request is made by using the beacon API (fetch + keepalive)
-        if (sendAndForget) {
-            const stringData = stringifyJSON(data);
-            const currentPayloadSize = new Blob([stringData]).size;
-            // if we have a large object or fetch is not available, we skip sending the message
-            if (currentPayloadSize > MAX_BEACON_PAYLOAD_SIZE) {
-                return Promise.resolve();
-            }
-            return unwrapNoibuWrapped(fetch)(url, {
-                method: 'POST',
-                headers: headersWithUa,
-                body: stringifyJSON(data),
-                // keep alive outlives the current page, its the same as beacon
-                keepalive: true,
-            });
-        }
-        return new Promise((resolve, reject) => {
-            const xhr = new XMLHttpRequest();
-            xhr.open(method, url);
-            xhr.timeout = timeout;
-            Object.keys(headersWithUa).forEach(header => {
-                xhr.setRequestHeader(header, headers[header]);
-            });
-            xhr.onload = () => {
-                if (xhr.status >= 200 && xhr.status < 300) {
-                    resolve(xhr.response);
-                }
-                else {
-                    reject(new Error(`Custom Request failed: ${xhr.statusText}`));
-                }
-            };
-            xhr.onerror = () => {
-                reject(new Error(`Custom Request failed: ${xhr.statusText}`));
-            };
-            if (data) {
-                xhr.send(stringifyJSON(data));
-            }
-            else {
-                xhr.send();
-            }
-        });
-    });
+function postRequest(url, data, headers, sendAndForget = false, timeout = 2000) {
+    if (typeof fetch !== 'function') {
+        return Promise.resolve();
+    }
+    const body = asString(data);
+    const currentPayloadSize = new Blob([body]).size;
+    if (sendAndForget && currentPayloadSize > MAX_BEACON_PAYLOAD_SIZE) {
+        return Promise.reject("Can't queue data for transfer due to it's size.");
+    }
+    const init = {
+        method: 'POST',
+        headers,
+        body,
+        keepalive: sendAndForget,
+    };
+    let timer;
+    if (typeof AbortController !== 'undefined') {
+        const controller = new AbortController();
+        init.signal = controller.signal;
+        timer = setTimeout(() => controller.abort('Timeout exceeded'), timeout);
+    }
+    const originalFetch = unwrapNoibuWrapped(fetch);
+    const promise = originalFetch(url, init).then(() => { });
+    if (typeof AbortController !== 'undefined') {
+        promise.finally(() => clearTimeout(timer));
+    }
+    return promise;
 }
 /**
  * makes sure the url sent is a valid URL
@@ -202,20 +172,6 @@ function getUserAgent() {
         return userAgentCache;
     });
 }
-/**
- * isInvalidURLConfig will verify that Collect is being initializes with
- * the correct env vars.
- */
-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;
-        }
-    }
-    return false;
-}
 /**
  * isNoibuJSAlreadyLoaded will verify if there are already other
  * copies of NoibuJS runnung
@@ -249,9 +205,7 @@ function asString(obj) {
  */
 function maskTextInput(text) {
     // if it has an email or digit(s), we mask the text
-    return text
-        .replace(PII_EMAIL_PATTERN, PII_REDACTION_REPLACEMENT_STRING)
-        .replace(PII_DIGIT_PATTERN, '*');
+    return text.replace(PII_EMAIL_PATTERN, PII_REDACTION_REPLACEMENT_STRING).replace(PII_DIGIT_PATTERN, '*');
 }
 /**
  * Checks if the provided object is an instance of the specified type.
@@ -266,20 +220,6 @@ function isInstanceOf(instance, type) {
         return false;
     }
 }
-/**
- * To grab the video recorder type based on the device we run the app on.
- */
-function getVideoRecorderType() {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (Platform.OS === 'android') {
-            return 'AndroidNative';
-        }
-        if (Platform.OS === 'ios') {
-            return 'IOSNative';
-        }
-        return '';
-    });
-}
 /** String.trim, but safe */
 function safeTrim(text) {
     if (typeof text !== 'string') {
@@ -290,9 +230,6 @@ function safeTrim(text) {
 /**
  * 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.
- *
- * @param {Error} error - The error object from which to retrieve the stack trace.
- * @returns {string} The stack trace of the error, if available. Otherwise, an empty string is returned.
  */
 function tryGetStackTrace(error) {
     let result = '';
@@ -306,13 +243,5 @@ function tryGetStackTrace(error) {
     }
     return result;
 }
-/**
- * Checks whether the given value is a string or an instance of String.
- * @param {*} value - The value to be checked.
- * @returns {boolean} Returns true if the value is a string or an instance of String, otherwise returns false.
- */
-function isString(value) {
-    return typeof value === 'string' || value instanceof String;
-}
 
-export { asString, getJSStack, getMaxSubstringAllowed, getUserAgent, getVideoRecorderType, isInstanceOf, isInvalidURLConfig, isNoibuJSAlreadyLoaded, isStackTrace, isString, isValidURL, makeRequest, maskTextInput, processFrames, safeTrim, stringifyJSON, tryGetStackTrace };
+export { asString, getJSStack, getMaxSubstringAllowed, getUserAgent, isInstanceOf, isNoibuJSAlreadyLoaded, isStackTrace, isValidURL, maskTextInput, postRequest, processFrames, safeTrim, stringifyJSON, tryGetStackTrace };

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

@@ -4,12 +4,10 @@
  * checks if was overridden and calls original console function
  */
 const getConsoleMethod = (ogProp) => {
-    // @ts-ignore
+    // @ts-expect-error __noibu_original__ is not a standard property
     return console[ogProp].__noibu_original__ || console[ogProp];
 };
-/**
- * log with level = info
- */
+/**log with level = info */
 const noibuLog = (...msgs) => getConsoleMethod('log')('Noibu', ...msgs);
 
 export { noibuLog };

package/dist/{src/utils → utils}/object.d.ts

@@ -5,18 +5,20 @@
  * 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]: Function; }, K extends keyof A>(sourceObject: A, attributeName: K, processingFunction: (arg: A[K]) => A[K]) => void;
+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
- * @param anything
  */
 export declare function unwrapNoibuWrapped<T>(anything: {
     __noibu_original__?: T;
-} & T): 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
@@ -28,14 +30,14 @@ export declare const propWriteableOrMadeWriteable: <T>(proto: T, property: keyof
  * 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
+ * @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][];
+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

package/dist/utils/object.js

@@ -6,16 +6,13 @@
  * 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
  */
-const replace = (sourceObject, attributeName, processingFunction) => {
+function replace(sourceObject, attributeName, processingFunction) {
     if (!(attributeName in sourceObject)) {
         return;
     }
     const originalAttribute = sourceObject[attributeName];
-    const newValue = processingFunction(originalAttribute);
+    const newValue = processingFunction.call(sourceObject, originalAttribute);
     if (typeof newValue === 'function') {
         try {
             newValue.prototype = newValue.prototype || {};
@@ -40,14 +37,19 @@ const replace = (sourceObject, attributeName, processingFunction) => {
     }
     // 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 if the given object is wrapped
+ */
+function isNoibuWrapped(anything) {
+    return '__noibu_original__' in 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
@@ -55,9 +57,7 @@ function unwrapNoibuWrapped(anything) {
  * returns 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)) {
+    if (!proto || !proto.hasOwnProperty || !Object.prototype.hasOwnProperty.call(proto, property)) {
         return false;
     }
     // Getting the properties that this the prototype
@@ -82,7 +82,7 @@ const propWriteableOrMadeWriteable = (proto, property) => {
  * 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
+ * @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
  */
@@ -171,4 +171,4 @@ const safeFromEntries = (entries) => {
     return obj;
 };
 
-export { iterateObjectRecursively, propWriteableOrMadeWriteable, replace, safeEntries, safeFromEntries, unwrapNoibuWrapped };
+export { isNoibuWrapped, iterateObjectRecursively, propWriteableOrMadeWriteable, replace, safeEntries, safeFromEntries, unwrapNoibuWrapped };

package/dist/{src/utils → utils}/performance.d.ts

@@ -3,4 +3,4 @@
  * it's available before calling it. If it's not available,
  * we return Date.now() instead.
  */
-export declare function safePerformanceNow(): any;
+export declare function safePerformanceNow(): number;

package/dist/utils/piiRedactor.js

@@ -1,7 +1,36 @@
 import { iterateObjectRecursively } from './object.js';
-import { HTTP_PII_BLOCKING_PATTERNS, PII_REDACTION_REPLACEMENT_STRING } from '../constants.js';
+import { PII_REDACTION_REPLACEMENT_STRING, PII_EMAIL_PATTERN } from '../constants.js';
 import { stringifyJSON } from './function.js';
 
+// Regex patterns for a best-effort attempt at blocking PII in HTTP requests
+const HTTP_PII_BLOCKING_PATTERNS = [
+    // Match credit cards [https://www.regular-expressions.info/creditcard.html]
+    // Visa
+    /\b4\d{12}(?:\d{3})?\b/g,
+    // MasterCard
+    /\b(?:5[1-5]\d{2}|222[1-9]|22[3-9]\d|2[3-6]\d{2}|27[01]\d|2720)\d{12}\b/g,
+    // Amex
+    /\b3[47]\d{13}\b/g,
+    // Diners Club
+    /\b3(?:0[0-5]|[68]\d)\d{11}\b/g,
+    // Discover
+    /\b6(?:011|5\d{2})\d{12}\b/g,
+    // JCB
+    /\b(?:2131|1800|35\d{3})\d{11}\b/g,
+    // Emails [https://www.regular-expressions.info/email.html]
+    PII_EMAIL_PATTERN,
+    // US SSN with or without dashes
+    // [https://www.oreilly.com/library/view/regular-expressions-cookbook/9781449327453/ch04s12.html]
+    /\b(?!000|666)[0-8]\d{2}[-.● ]?(?!00)\d{2}[-.● ]?(?!0000)\d{4}\b/g,
+    // Canadian SIN with or without dashes [https://regexpattern.com/social-insurance-number-ca]
+    /\b(\d{3}[-.● ]?\d{3}[-.● ]?\d{3})\b/g,
+    // International phone numbers
+    // [https://www.oreilly.com/library/view/regular-expressions-cookbook/9781449327453/ch04s03.html]
+    /\+(?:\d●?){6,14}\d\b/g,
+    // US/Canada phone numbers
+    // [https://www.oreilly.com/library/view/regular-expressions-cookbook/9781449327453/ch04s02.html]
+    /(\b|\+)?(1[-.● ]?)?\(?(\d{3})\)?[-.● ]?(\d{3})[-.● ]?(\d{4})\b/g,
+];
 const fuzzyFieldsToRedact = [
     'password',
     'address',
@@ -35,8 +64,7 @@ const exactFieldsToRedact = [
  */
 function shouldRedact(field) {
     // check for exact and fuzzy matches
-    return (exactFieldsToRedact.some(v => field === v) ||
-        fuzzyFieldsToRedact.some(v => field.indexOf(v) >= 0));
+    return exactFieldsToRedact.some(v => field === v) || fuzzyFieldsToRedact.some(v => field.indexOf(v) >= 0);
 }
 /**
  * Try to parse content as a JSON object and